convez.ai
SkillAutomaçãoAvançado
Dong90

TaiyiForge

Dong90/oh-my-taiyiforge

Fluxo de R&D com gates, não vibes — nove fases, um comando.

Ver no GitHub
BomPluginScore · de 0 a 100

Motor de fluxo de trabalho R&D em IA que orquestra seis padrões de engenharia em nove estágios executáveis, com gates obrigatórios para cada fase. Transforma requisição → design → desenvolvimento → teste → review → arquivo em um contrato de artefatos auditável, integrando Harness, OpenSpec, GStack e outras standards numa única máquina de estados.

Instalação

$npx convez-ai Dong90/oh-my-taiyiforge

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
855
Forks
24
Acompanhando
11
Saúde
71%
Último commit
há 4 dias
Versão
v1.1.0
Issues abertas
6
Contribuidores
1

Casos de uso

  • Orquestração de workflows R&D em equipes usando Claude, OpenCode ou Codex
  • Garantir completude de documentação (REQUIREMENT, DESIGN, CHANGE) antes de código
  • Auditoria de artefatos intermediários com rastreamento de contexto compacto
  • Sincronização de fluxos de trabalho entre múltiplas plataformas de IA

Veredito

Ferramenta robusta e opinada para equipes que precisam de rigor processual em workflows de IA. Resolve o problema real de agentes que pulam fases, mas exige disciplina organizacional para adoção — não é para prototipação rápida.

README

A tradução para o português deste README ainda está na fila.

English · 简体中文

TaiyiForge

Turn six AI engineering standards into a single executable nine-stage R&D workflow

License: MIT Node

Version CI Platforms

Document-driven AI R&D with gates, not vibes.

Stop memorizing the phase order. Say /taiyi:new and the engine tells you what's next.

Quick Start · Usage Guide · Architecture · Command Reference · Full Flow · Contributing

TaiyiForge Architecture — Six standards × Workflow engine × Nine stages × Skill universe × Three-layer gates

4K visual poster (non-technical source) · Editable source: SVG · C4


TL;DR (30 seconds)

Real terminal demo

27-second real terminal recording · asciicast source (playable on asciinema.org or locally with asciinema play docs/diagrams/demo.cast)

  • What it is: An AI R&D workflow engine that turns "requirement → design → dev → test → review → archive" into a nine-stage artifact contract, plus 23 taiyi-* Skills.
  • Who it's for: Teams and individuals using OpenCode / Claude / Codex / Cursor for serious projects (medium-or-larger, with review, with delivery gates).
  • How to use it: In your project, run taiyi new "feature name". The engine guides you to write CHANGE.md / REQUIREMENT.md / DESIGN.md … All nine stages complete, every intermediate artifact is auditable.
  • Why not another standard: TaiyiForge does not invent standards — it orchestrates Harness · OpenSpec · GStack · Superpowers · OMO · Spec-Kit into one state machine. Use what you have installed; everything else is auto-skipped as optional.

Why TaiyiForge?

Pain you've hitTaiyiForge's answer
Agent forgets the phase order mid-task and jumps to codePrevious stage incomplete → engine rejects continue; dev stage forces TDD
Context explodes mid-change, requirements / design / code all lostEverything lives under .taiyi/changes/<slug>/; token overflow auto-writes CONTEXT-COMPACT.md
Each of OpenCode / Claude / Codex / Cursor has its own ad-hoc flowOne set of taiyi-* Skills, sync to any of the four harnesses
Even a typo fix has to go through nine stages?7 profiles (full → nano), auto-routes by change complexity
Don't dare let AI decide at critical nodeschange / design / review are human gates + --approver, skipped only when --approver is set
Don't know what the installed Skills are actually doingtaiyi doctor / audit self-check + failures / high-findings triage
Want to coexist with OMC / OMXDoesn't depend on oh-my-claudecode; Taiyi owns artifacts, OMX owns parallel execution

The Nine-Stage Workflow

One change = one slug, sequential execution, fixed artifacts. Human gates require --approver before the engine lets you pass.

#PhaseCategorySkillArtifactNotes
1changeHuman gatetaiyi-changeCHANGE.md3-5 paragraph proposal with scope
2requirementAutotaiyi-requirementREQUIREMENT.mdAcceptance criteria + AC checkbox
3designHuman gatetaiyi-designDESIGN.md≥2 options compared + decision
4ui-designAutotaiyi-ui-designUI-DESIGN.mdOnly for changes that touch UI
5taskAutotaiyi-taskTASK.mdSlice into independently-PR-able pieces
6devAutotaiyi-devTDD test + minimal implTDD forced — red first, then green
7testAutotaiyi-testTEST.mdSummary kept; E2E runs in CI
8reviewHuman gatetaiyi-reviewREVIEW.mdCross-AI review + high-severity must-fix
9integrationAutotaiyi-integrationCHANGELOG.md mergedDelivery gate: audit + deliveryVerifyCmd
—archiveCleanuptaiyi-integration.taiyi/archive/Only after all nine stages pass

Full command list → canonical-commands.md · Artifact layout → artifact-layout.md


One Skill Set, Four Harnesses

One taiyi-forge-install --all syncs to all four harnesses; missing ones are auto-skipped:

HarnessHow to verifyNotes
OpenCodeopencode.json contains oh-my-taiyiforge; after restart you'll see taiyi_new / taiyi_* toolsOfficial plugin, deep integration
Claude Codels ~/.claude/skills/taiyi-change · ~/.claude/mcp.jsonSlash / Skill / MCP
Codexls ~/.codex/skills/taiyi-change · ~/.codex/mcp.json$taiyi-* keyword-driven
Cursor~/.cursor/skills/taiyi-change · taiyiforge.mdc · project .cursor/mcp.jsonRule + MCP dual channel

Codex users trigger via $taiyi-new / $taiyi-forge etc. — see agents.yaml.


Quick Start

Status note: v0.23.0 is not yet published to npm. The only install path right now is from source. CI is green, npm will follow; badges will switch automatically.

Option A: Source install (recommended, ready now)

git clone https://github.com/Dong90/oh-my-taiyiforge.git
cd oh-my-taiyiforge
npm install && npm run build && npm test

Option B: Install into your project (also source)

git clone https://github.com/Dong90/oh-my-taiyiforge.git
cd oh-my-taiyiforge
npm install && npm run build

# Install to all four harnesses + optional triangles
# (OpenSpec / gstack / Superpowers / web-quality-skills)
node scripts/taiyi-forge.sh install --all

# Or one harness at a time:
node scripts/taiyi-forge.sh install --cursor
node scripts/taiyi-forge.sh install --claude --cursor
# Skip optional deps:
node scripts/taiyi-forge.sh install --all --skip-deps

Option C: Run the demo projects

cd examples/commands-smoke
npm install
npm run chat-demo          # Chat verbs: new / status / check / continue
npm run walkthrough-e2e    # Nine-stage shell E2E + iron-triangle
npm run taiyi:doctor       # Workspace + install self-check

Want npm install oh-my-taiyiforge? Wait for the Releases announcement — it'll light up here first.


Your First Change (5 minutes)

mkdir demo && cd demo
npm init -y
git clone https://github.com/Dong90/oh-my-taiyiforge.git .taiyi-forge   # temporary engine
# (after npm publish, this becomes: npm install oh-my-taiyiforge)

# Recommended entry: auto-slug + engine guidance
npx taiyi walkthrough
npx taiyi new "Add login optimization"  # writes to .taiyi/changes/<slug>/
npx taiyi status                         # current phase + recommended Skill + next step

# Edit .taiyi/changes/<slug>/CHANGE.md, then:
npx taiyi complete <slug> change --approver "your-name"   # human gate
npx taiyi continue <slug>                                 # auto gate

# In chat (OpenCode / Claude / Cursor):
/taiyi:new "feature description"
/taiyi:status
/taiyi:write                       # write current stage artifact
/taiyi:continue --approver "your-name"
/taiyi:commit                      # post-dev commit with Taiyi-Change trailer
/taiyi:archive                     # archive after all nine stages

That's it. Phase order, artifact templates, gate validation are the engine's job. You write Markdown and code.


Chat Track vs Engine Track

TaiyiForge deliberately splits responsibilities — similar to oh-my-claudecode's "session Skills + CLI control plane" idea, but the spine is the nine-stage artifact contract:

SurfaceUsed byDoes whatExample
Chat slashDeveloper / AgentWrite artifact, run TDD, load specialized Skill/taiyi:write · /taiyi:apply · /taiyi:tdd dev
Engine CLIAgent / CI (run for you)Validate artifact, gates, advance phasenpx taiyi continue <slug> · npx taiyi complete <slug> change --approver "…"
Shell entryAgent / CIEquivalent to CLI; written into consumer project after installscripts/taiyi-forge.sh status --json --compact
MCPCursor etc.Read-only troubleshootingtaiyi_doctor · taiyi_audit

Principle: Users only say /taiyi:*; never make the user type taiyi-forge.sh by hand. Agents read status --json --compact engineTruth; never dump full artifacts into chat.

Agent-priority troubleshooting:

scripts/taiyi-forge.sh doctor --json --compact
scripts/taiyi-forge.sh audit --json --compact

Core Capabilities

  • Nine-stage artifact contract — requirement → design → dev → test → review → archive, all auditable under .taiyi/changes/<slug>/
  • Agent cannot skip stages — previous stage incomplete ⇒ engine rejects continue; dev forces TDD; integration runs the delivery gate
  • One Skill set, four harnesses — 23 taiyi-* synced to OpenCode / Claude / Codex / Cursor via taiyi-forge-install
  • Right-sized routing — 7 profiles (full → nano); big features go nine-stage, typo fixes go nano
  • Compose, don't lock-in — Harness · OpenSpec · GStack · Superpowers · OMO · Spec-Kit integrations; not installed = auto-skipped as optional
  • Long sessions survive — token budget + /taiyi:token compress → CONTEXT-COMPACT.md + handoff
  • Coexists with OMC / OMX — doesn't depend on oh-my-claudecode; pairs with oh-my-codex for multi-agent orchestration (Taiyi = artifacts, OMX = parallel execution)
  • TDD forced — dev stage: failing test first, minimal impl second; npm test must pass before advancing to test stage
  • Platform smoke — CI matrix runs OpenCode / Claude / Codex / Cursor, prevents single-platform drift

Architecture at a Glance

┌─────────────────────────────────────────────────────────────┐
│  Entry: taiyi CLI · taiyi-forge.sh · OpenCode plugin · MCP    │
└───────────────────────────┬─────────────────────────────────┘
                            ▼
┌─────────────────────────────────────────────────────────────┐
│  workflow-engine — intent analysis · token budget · routing · gates │
└───────────────────────────┬─────────────────────────────────┘
                            ▼
┌─────────────────────────────────────────────────────────────┐
│  .taiyi/changes/<slug>/  — CHANGE … CHANGELOG (source of truth)  │
└─────────────────────────────────────────────────────────────┘
         chat loads taiyi-* Skill to write artifacts ↑   ↓ engine validates & advances phase

Documentation

DocumentWhat it coversWhen to read
docs/QUICKSTART.md5-minute walkthroughFirst install
docs/USAGE.mdScenarios · daily rhythm · delivery chainAfter the walkthrough
docs/ARCHITECTURE.mdArchitecture overview + code layoutHacking the engine / debugging
docs/taiyi/canonical-commands.mdv28 slash command tableLooking up a command
docs/taiyi/control-plane.mdAgent discipline + token disciplineOnboarding an Agent
docs/taiyi/full-oss-flow.mdSuperpowers + all-plugins demoWant a full end-to-end
docs/taiyi/integrations.mdIron triangle + plugin integrationsInstalling optional pieces
AGENTS.mdAgent's read-state entry pointConfiguring Agents
CONTRIBUTING.mdContribution guideBefore opening a PR
CHANGELOG.mdRelease notesChecking for updates
docs/diagrams/demo.gifReal terminal recording (27s)Quick feel of the engine
README.zh-CN.md简体中文版中文用户

Development & Verification

Contributor clone:

git clone https://github.com/Dong90/oh-my-taiyiforge.git
cd oh-my-taiyiforge
npm install && npm run build && npm test
npx taiyi-forge-install --all

Common commands:

npm test               # Vitest contracts + nine-stage E2E
npm run test:watch     # watch mode
npm run build          # TypeScript → dist/
npm run dogfood        # root repo demo (eat your own dog food)
npm run ci:platforms   # four-platform smoke (opencode/claude/codex/cursor)
npm run check:docs     # doc-vs-commands.yaml sync check

Example projects:

DirectoryPurpose
examples/full-flow-demoNine-stage + slash E2E
examples/commands-smokeCommand smoke tests
examples/browser-e2e-smokeCI templates
examples/verification-suiteMinimal integration demo

CI: .github/workflows/ci.yml — platform smoke runs across a 4 × ubuntu matrix.


Roadmap & Status

VersionStatusKey milestones
v0.23.0✅ Releasedcanonical v28 convergence · catalog-validation gate · skill-fusion principles documented
v0.24.x🚧 In progressFirst npm release · oh-my-taiyiforge zero-build install for consumer projects
v1.0.0⏳ PlannedLock 9-stage API · 4-platform parity · external case-study collection

Ready today: full nine-stage pipeline · four-harness shared Skills · forced TDD · token compression · platform-smoke CI Not yet: one-line npm install (v0.24 target) · production-grade SLA · full i18n


Community & Contributing

  • 🐛 Report a bug: GitHub Issues · bug label
  • 💡 Idea / RFC: Discussions
  • 🔧 Open a PR: read CONTRIBUTING.md first; npm test + npm run check:docs must be green
  • ⭐ Star / Watch: drop a star to get notified on the next release
  • 🧵 Codex users: search for $taiyi-* keywords; four-harness entry decision tree in docs/taiyi/invoke.yaml

Code of conduct: follow the Contributor Covenant spirit — critique ideas, not people.


License

MIT © 2026 TaiyiForge contributors

Acknowledgments

Inspired by: oh-my-claudecode · oh-my-codex · Harness Engineering · OpenSpec · GStack · Superpowers · OMO · Spec-Kit.

Ver o original no GitHub

Bom para

Relacionados