convez.ai
AgenteDesenvolvimento WebAvançado
chuckplayer

Claude Agent Pack

chuckplayer/claude-agent-pack

Orquestração inteligente de agentes especializados para desenvolvimento enterprise

Ver no GitHub
InicialPluginScore · de 0 a 100

Conjunto de 21 agentes especializados que orquestram tarefas complexas de desenvolvimento enterprise em C# e TypeScript. Cada agente é um especialista focado (arquiteto, revisor de código, engenheiro de BD, etc.) que trabalha em paralelo ou sequência conforme as dependências, com memória persistente em Obsidian para contexto de projeto.

Instalação

$npx convez-ai chuckplayer/claude-agent-pack

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
8
Forks
2
Acompanhando
0
Saúde
42%
Último commit
há 1 mês
Versão
—
Issues abertas
0
Contribuidores
1

Casos de uso

  • Refatorações arquiteturais complexas com revisão automática de segurança e performance
  • Implementação de features multi-camada (API + serviços C# + frontend TypeScript) com testes gerados
  • Gestão de mudanças de schema de banco com migrações EF Core e validação de impacto
  • Detecção automática de anti-padrões e débito técnico durante implementação

Veredito

Ferramenta madura para times enterprise que precisam escalar desenvolvimento sem perder qualidade. A orquestração inteligente de agentes especializados resolve o problema real de context-switching em tarefas complexas, mas exige infraestrutura consolidada (Git, Obsidian, MCP servers) para máximo valor.

README

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

Claude Code Agent Pack

Twenty-one specialized Claude Code subagents for enterprise software development teams, an Obsidian vault integration, and persistent knowledge management.

Why

Claude Code works best on large, complex tasks when it can delegate to focused specialists rather than context-switching across domains in a single session. This pack provides twenty-one agents that Claude Code orchestrates automatically -- routing to the right specialist based on what the task requires, running parallel agents when there are no dependencies, and sequencing reviews after implementation.

Without orchestration, a single session planning an architecture change, writing C# services, reviewing them, and writing tests quickly loses coherence. With the pack, each agent is narrow enough to be consistently good at its job, and session context is automatically logged to an Obsidian vault on Stop.

Agents

AgentRoleWhen invoked
tech-leadDecomposes complex tasks and orchestrates specialist agentsAmbiguous or multi-step tasks spanning multiple files or layers
devils-advocatePressure-tests reasoning before implementation beginsNew patterns, architectural decisions, irreversible changes
api-designerDesigns REST contracts before implementation beginsCreating or significantly modifying API endpoints
git-engineerGit lifecycle specialist: branch setup, conventional commits, push, and PRBefore any engineer agent; after merge-reviewer for push/PR
csharp-engineerC# and .NET implementationWriting or modifying .cs files
python-engineerPython implementation: FastAPI, Django, Flask, and plain PythonWriting or modifying .py files
frontend-engineerTypeScript and Vue 3 frontend implementationWriting or modifying .ts or .vue files
mcp-engineerMCP server implementation: tools, resources, prompts, Zod schemasBuilding or modifying MCP servers
infrastructure-engineerInfrastructure-as-code: Terraform, Docker, GitHub Actions, KubernetesWriting or modifying .tf, Dockerfiles, .yml in .github/, and K8s manifests
ts-linterType checking (tsc) and ESLint on changed TS/Vue filesAfter frontend-engineer or mcp-engineer, before code-reviewer
database-engineerSchema changes, EF Core migrations, and SQLAny task requiring schema changes or migrations
code-reviewerCode quality, readability, and convention complianceAfter any engineer agent output
security-reviewerSecurity-focused review onlyChanges touching auth, data access, PII, or secrets
performance-reviewerPerformance-focused review onlyChanges with database queries, endpoints, or hot-path code
smell-reviewerStructural anti-pattern detection: God classes, long methods, dead code, feature envy, comment smells (TODO/HACK/FIXME/XXX). Offers to record accepted patterns as suppressions in CONVENTIONS.mdAfter code-reviewer on every code change; parallel with security-reviewer and performance-reviewer
test-engineerTest generation matching established project patternsAfter code-reviewer has completed its review
merge-reviewerFinal pipeline gate -- verifies all stages passed and commits to the feature branchAfter test-engineer completes; never merges to main
obsidian-writerWrites session logs and capture notes to the vault via filesystem; skips the main file when the calling skill already wrote it via REST API and handles only the daily note appendDispatched by Obsidian skills; never writes outside allowed vault directories

Installation

Clone the repo anywhere, then run the installer:

git clone https://github.com/chuckplayer/claude-agent-pack.git
bash ./claude-agent-pack/install.sh

After the installer runs, scaffold each project using the setup script. Replace <pack-dir> with the path to your clone and <project> with your project root:

bash <pack-dir>/scripts/setup-project.sh <project>

This copies CLAUDE.md, docs/CONVENTIONS.md (from the template), docs/MEMORY-WRITING.md, and the memory/ scaffold into the project. Then fill in docs/CONVENTIONS.md with your project's standards and commit the result.

Skills

Twenty-two slash-command entry points are included. Invoke them directly in Claude Code without knowing the agent sequence:

SkillWhat it does
/implementRuns the full pipeline: git-engineer → [tech-lead] → engineer(s) → ts-linter → code-reviewer → [security-reviewer] → [performance-reviewer] → smell-reviewer → test-engineer → merge-reviewer → git-engineer (push/PR). Engineers run in isolated worktrees.
/interview-meShape a vague idea into an actionable brief through structured one-at-a-time questioning. Terminates when the user signals readiness or all major branches resolve; produces an optional design brief that feeds into /plan or /implement.
/scaffoldEnd-to-end feature scaffolding: api-designer → database-engineer → backend engineer → frontend-engineer, in dependency order. Use when building something new across all layers.
/hotfixAbbreviated pipeline for production incidents. No worktree isolation, 1 retry max. Still requires code-reviewer and merge-reviewer.
/refactorRefactor with impact analysis first: tech-lead → engineer(s) → mandatory test verification → code-reviewer. Enforces a no-behavior-delta constraint.
/debugDiagnose and fix a failing test or error. Reads the stack trace, forms a hypothesis, routes to the right engineer, then runs a lightweight code-reviewer pass.
/review-prRuns code-reviewer, security-reviewer, performance-reviewer, and smell-reviewer against a PR or diff. Produces a consolidated findings report.
/smellRun smell-reviewer against a file, directory, or working-tree changes. Detects structural anti-patterns and comment smells; offers to record accepted patterns in CONVENTIONS.md.
/planDecompose a task with tech-lead and optionally pressure-test the plan with devils-advocate before implementation begins.
/onboardReads the codebase, memory, and conventions to produce a structured orientation: architecture, entry points, data flow, and known gotchas.
/conventionsScaffolds or updates docs/CONVENTIONS.md by reading actual code patterns and interviewing the user.
/memory-auditReviews all active memory files for staleness, archives stale entries, and checks for unrecorded decisions.
/memory-querySearches project memory for a specific topic, decision, or constraint and returns matching entries with citations.
/lint-agentsValidates all agent and skill files for required frontmatter fields and body content; interprets failures with specific fix instructions.
/setup-projectScaffolds a project with CLAUDE.md, docs/CONVENTIONS.md, docs/MEMORY-WRITING.md, and the memory/ structure, then guides through next steps
/system-checkRuns both readiness and update checks in one pass: verifies installation, project scaffolding, and whether agents/skills are current.
/obsidianHelp and routing entry point for the Obsidian skill family — dispatches to the right skill based on intent.
/obsidian-briefSynthesizes a context brief from recent session logs and captures for the current project — what was built, decisions made, and open threads. Run before /implement to load project context.
/obsidian-logLogs the current session to the Obsidian vault: git branch, recent commits, and uncommitted changes.
/obsidian-captureSaves a user-supplied title and body as a timestamped capture note in Claude/captures/.
/obsidian-dailyReads and displays today's project daily note (path depends on OBSIDIAN_PROJECTS_FOLDER).
/obsidian-searchFull-text search across Claude notes in the vault, scoped to the current project by default; pass --global to search all projects. Opens the best match in Obsidian if the REST API is available.

Obsidian Vault Integration

The installer optionally connects Claude Code to an Obsidian vault. When enabled, every session is automatically logged to your vault when Claude Code stops.

What gets written per session:

  • <base>/sessions/YYYY-MM-DD-HHmm-<project>.md — git branch, last 5 commits, diff stat, uncommitted changes, what was discussed (every prompt you sent), which agents ran, and any decisions Claude recorded
  • <base>/daily/YYYY-MM-DD.md — one timestamped line per session linking to the session note, including a compact diff stat (· 11 files +99 -87)
  • <base>/decisions/<file>.md — auto-captured when memory/decisions/ gains a new or changed file; links into the daily note
  • <base>/memory-snapshot.md — freeze of ./memory/**/*.md (recursive) for vault-side search

How decisions get recorded: a CLAUDE.md rule instructs Claude to append to ~/.claude/session-decisions.txt whenever a significant architectural choice is made. The Stop hook reads this file and populates the ## Decisions made section of the session log, then clears it for the next session.

Where <base> is determined by two env vars set during install:

Env varDescription
OBSIDIAN_VAULT_PATHAbsolute path to your vault (required)
OBSIDIAN_PROJECTS_FOLDERFolder inside the vault for project logs (defaults to Claude/Projects if blank)
OBSIDIAN_REST_API_KEYAPI key for the Obsidian Local REST API plugin (optional). When set, writes go through the REST API first with filesystem fallback. When absent, writes go directly to the filesystem.
OBSIDIAN_REST_API_PORTREST API port (default 27124 when key is set)
OBSIDIAN_REST_API_HTTPStrue/false — whether the REST API uses HTTPS (default true)

With OBSIDIAN_PROJECTS_FOLDER=Projects and project agent-pack: <vault>/Projects/agent-pack/sessions/, <vault>/Projects/agent-pack/daily/

Default (OBSIDIAN_PROJECTS_FOLDER=Claude/Projects when blank): <vault>/Claude/Projects/agent-pack/sessions/, <vault>/Claude/Projects/agent-pack/daily/

Setup: the installer prompts for your vault path, an optional projects folder, and an optional REST API key. If the key is provided, writes go through the Obsidian Local REST API first (filesystem fallback on any failure). Without a key, writes go directly to the filesystem — Obsidian's file watcher picks them up within seconds either way.

Manual skills: use /obsidian-brief, /obsidian-log, /obsidian-capture, /obsidian-daily, and /obsidian-search at any time regardless of the auto-log hook.

Scripts

Seven utility scripts are included in scripts/.

ScriptWhat it does
setup-projectCopies CLAUDE.md, docs/CONVENTIONS.md, docs/MEMORY-WRITING.md, and the memory/ scaffold into a project directory
check-readinessVerifies Claude Code is installed, all agents and skills are installed, and the target project has full scaffolding
check-updatesDiffs installed agents and skills against the pack source; flags anything outdated
lint-agentsValidates all agent and skill files for required frontmatter fields, description length, and body content
obsidian-stop-hookAuto-log hook (.js, pure Node.js) — installed to ~/.claude/scripts/; fires on Stop and SessionEnd; writes the session note and daily note; tries REST API when OBSIDIAN_REST_API_KEY is set, falls back to filesystem
obsidian-prompt-hookPrompt capture hook (.js, pure Node.js) — installed to ~/.claude/scripts/; fires on UserPromptSubmit; appends each user prompt to a per-session journal for inclusion in the session log
obsidian-agent-hookAgent completion hook (.js, pure Node.js) — installed to ~/.claude/scripts/; fires on SubagentStop; records which agents ran during the session for inclusion in the session log
bash scripts/setup-project.sh <project>
bash scripts/check-readiness.sh <project>
bash scripts/check-updates.sh
bash scripts/lint-agents.sh

Quick Start

Use skills as entry points:

/plan add a payment processing feature
/implement add a GetByExternalId method to OrderRepository
/scaffold add a notifications feature with API, DB, backend, and frontend
/review-pr 42
/debug the OrderService.GetById test is failing with a null reference exception
/hotfix fix the null check in PaymentController.ProcessRefund
/refactor extract the retry logic in HttpClientWrapper into a separate class
/onboard
/conventions
/memory-audit
/setup-project
/system-check
/obsidian-log
/obsidian-capture my design decision: keep auth in middleware, not controllers
/smell
/smell src/services/OrderService.cs

Or invoke agents directly in natural language:

  1. "Use the tech-lead agent to plan adding a payment processing feature."
  2. "Use the csharp-engineer to add a GetByExternalId method to OrderRepository."
  3. "Use the code-reviewer to review the changes in OrderService.cs."
  4. "Use the test-engineer to write xUnit tests for the new OrderService.GetById method."

Workflow

task -> git-engineer -> [tech-lead] -> [devils-advocate] -> [api-designer] -> engineer(s) -> [ts-linter] -> code-reviewer -> [security-reviewer] -> [performance-reviewer] -> smell-reviewer -> test-engineer -> merge-reviewer -> git-engineer (push/PR)

Bracketed agents are conditional. For well-defined tasks, invoke the specialist directly and skip orchestration. git-engineer is skipped for read-only tasks. ts-linter runs only when TypeScript or Vue files were modified. database-engineer runs in parallel with engineer agents when schema changes are needed. security-reviewer and performance-reviewer run when their trigger conditions are met. smell-reviewer always runs on code changes and runs in parallel with security-reviewer and performance-reviewer. When invoked through /implement, engineer agents run in isolated git worktrees and merge-reviewer commits the result to the feature branch if all gates pass.

Memory

The memory/ directory gives agents a lightweight persistence layer. Decisions, architectural context, and known issues are stored as Markdown files that survive between sessions.

Memory is committed to version control so the full team shares accumulated context. When the tech-lead records an architectural decision, every future agent session in that codebase picks it up automatically.

Who writes: tech-lead (for decisions) and devils-advocate (for challenge sessions). All other agents are read-only.

File naming: YYYY-MM-DD-[decision|challenge]-brief-slug.md in the appropriate subdirectory.

Agents skip files with status: superseded or status: archived automatically.

See docs/AGENT-GUIDE.md for the full memory format, hygiene guidance, and scaling notes.

Customization

Fill in docs/CONVENTIONS.md with your project's naming conventions, architectural rules, error handling strategy, logging standards, and compliance requirements. All agents read this file before acting. Team standards override agent defaults automatically -- no changes to agent files required.

Project-Level Overrides

Place an agent file in .claude/agents/ in the project root to override the global version for that project. The filename must match the global agent (e.g., csharp-engineer.md). The project-level version takes full precedence for sessions in that project.

Updating

To check whether your installed agents and skills are current before pulling:

bash scripts/check-updates.sh

To pull and reinstall:

# from your clone directory
git pull
bash install.sh

Agents are updated in-place. Re-running the installer is safe -- it is idempotent.

Uninstalling

bash <pack-dir>/uninstall.sh

The uninstaller removes agents from ~/.claude/agents/, skills from ~/.claude/skills/, all three Obsidian hook scripts (obsidian-stop-hook.js, obsidian-prompt-hook.js, obsidian-agent-hook.js) from ~/.claude/scripts/, and all Obsidian env vars (OBSIDIAN_VAULT_PATH, OBSIDIAN_PROJECTS_FOLDER, OBSIDIAN_REST_API_KEY, OBSIDIAN_REST_API_PORT, OBSIDIAN_REST_API_HTTPS) from ~/.claude/settings.json — all after confirmation. Project-level memory/ directories are not touched.

Agent Dashboard

claude-agent-dashboard is a companion local web UI for monitoring Claude Code sessions in real time.

  • Live session feed — agent Gantt timeline and scrolling event log, updated within 1 second of any Claude Code hook event
  • Memory browser — browse and search memory/*.md files across all projects; renders full markdown on click
  • Session history — SQLite-backed log of past sessions with duration, prompt counts, and agent invocation counts

The dashboard works with any Claude Code installation. The agent pack is optional — if both are installed, the memory browser surfaces the architectural decisions and challenge records that tech-lead and devils-advocate write during sessions.

Requires Node.js 22+ (uses the built-in node:sqlite module). Nothing leaves your machine — the server binds to 127.0.0.1 only.

License

MIT. See LICENSE.

Ver o original no GitHub

Bom para

Relacionados