mirror of
https://github.com/affaan-m/everything-claude-code.git
synced 2026-03-31 22:23:27 +08:00
ebd8c8c6fa
* feat(agents): add Rust language support — reviewer, build resolver, patterns, and testing
Add Rust-specific agents and skills following the established Go/Kotlin pattern:
- agents/rust-reviewer.md: ownership, lifetimes, unsafe audit, clippy, error handling
- agents/rust-build-resolver.md: cargo build errors, borrow checker, dependency resolution
- skills/rust-patterns/SKILL.md: idiomatic Rust patterns and best practices
- skills/rust-testing/SKILL.md: TDD, unit/integration/async/property-based testing
* fix(agents): correct Rust examples for accuracy and consistency
- unsafe fn: add inner unsafe {} block for Rust 2024 edition compliance
- edition: update from 2021 to 2024 as current default
- rstest: add missing fixture import
- mockall: add missing predicate::eq import
- concurrency: use sync_channel (bounded) and expect() over unwrap()
to align with rust-reviewer's HIGH-priority review checks
* fix(skills): correct compilation issues in Rust code examples
- collect: add .copied() for &str iterator into String
- tokio import: remove unused sleep, keep Duration
- async test: add missing Duration import
* fix(skills): move --no-fail-fast before test-binary args
--no-fail-fast is a Cargo option, not a test binary flag.
Placing it after -- forwards it to the test harness where it is
unrecognized.
* fix(agents): distinguish missing cargo-audit from real audit failures
Check if cargo-audit is installed before running it, so actual
vulnerability findings are not suppressed by the fallback message.
* fix: address automated review findings across all Rust files
- build-resolver: prefer scoped cargo update over full refresh
- testing: add Cargo.toml bench config with harness = false for criterion
- testing: condense TDD example to stay under 500-line limit
- patterns: use expect() over unwrap() on JoinHandle for consistency
- patterns: add explicit lifetime to unsafe FFI return reference
- reviewer: replace misleading "string interpolation" with concrete alternatives
* fix: align with CONTRIBUTING.md conventions
- skills: rename "When to Activate" to "When to Use" per template
- reviewer: add cargo check gate before starting review
* fix(agents): guard cargo-audit and cargo-deny with availability checks
Match the pattern used in rust-build-resolver to avoid command-not-found
errors when optional tools are not installed.
* fix: address second round of automated review findings
- testing: split TDD example into separate code blocks to avoid
duplicate fn definition in single block
- build-resolver/reviewer: use if/then/else instead of && ... ||
chaining for cargo-audit/deny to avoid masking real failures
- build-resolver: add MSRV caveat to edition upgrade guidance
* feat: add Rust slash commands for build, review, and test
Add commands/rust-build.md, commands/rust-review.md, and
commands/rust-test.md to provide consistent user entrypoints
matching the existing Go and Kotlin command patterns.
* fix(commands): improve rust-build accuracy and tone
- Restructure-first borrow fix example instead of clone-first
- Realistic cargo test output format (per-test lines, not per-file)
- Align "Parse Errors" step with actual resolver behavior
- Prefer restructuring over cloning in common errors table
* fix: address cubic-dev-ai review findings on commands
- Gate review on all automated checks, not just cargo check
- Use git diff HEAD~1 / git diff main...HEAD for PR file selection
- Fix #[must_use] guidance: Result is already must_use by type
- Remove error-masking fallback on cargo tree --duplicates
* fix: address remaining review findings across all bots
- Add rust-reviewer and rust-build-resolver to AGENTS.md registry
- Update agent count from 16 to 18
- Mark parse_config doctest as no_run (body is todo!())
- Add "How It Works" section to both Rust skills
- Replace cargo install with taiki-e/install-action in CI snippet
- Trim tarpaulin section to stay under 500-line limit
* fix(agents): align rust-reviewer invocation with command spec
- Use git diff HEAD~1 / main...HEAD instead of bare git diff
- Add cargo test as explicit step before review begins
* fix(skills): address cubic review on patterns and testing
- Remove Tokio-specific language from How It Works summary
- Add cargo-llvm-cov install note in coverage section
- Revert no_run on doctest examples (illustrative code, not compiled)
* fix(skills): use expect on thread join for consistency
Replace handle.join().unwrap() with .expect("worker thread panicked")
to match the .expect("mutex poisoned") pattern used above.
* fix(agents): gate review on all automated checks, not just cargo check
Consolidate check/clippy/fmt/test into a single gate step that
stops and reports if any fail, matching the command spec.
* fix(skills): replace unwrap with expect in channel example
Use .expect("receiver disconnected") on tx.send() for consistency
with the .expect() convention used in all other concurrency examples.
* fix: address final review round — OpenCode mirrors, counts, examples
- Add .opencode/commands/rust-{build,review,test}.md mirrors
- Add .opencode/prompts/agents/rust-{build-resolver,reviewer}.txt mirrors
- Fix AGENTS.md count to 20 (add missing kotlin agents to table)
- Fix review example: all checks pass (consistent with gate policy)
- Replace should_panic doctest with is_err() (consistent with best practices)
- Trim testing commands to stay at 500-line limit
* fix: address cubic and greptile review on OpenCode files and agents
- Fix crate::module import guidance (internal path, not Cargo.toml)
- Add cargo fmt --check to verification steps
- Fix TDD GREEN example to handle error path (validate(input)?)
- Scope .context() guidance to anyhow/eyre application code
- Update command count from 40 to 51
- Add tokio channel variants to unbounded channel warning
- Preserve JoinError context in spawned task panic message
* fix: stale command count, channel guidance, cargo tree fallback
- Fix stale command count in Project Structure section (40→51)
- Clarify unbounded channel rule: context-appropriate bounded alternatives
- Remove dead cargo tree fallback (exits 0 even with no duplicates)
- Sync OpenCode reviewer mirror with tokio channel coverage
152 lines
7.1 KiB
Markdown
152 lines
7.1 KiB
Markdown
# Everything Claude Code (ECC) — Agent Instructions
|
|
|
|
This is a **production-ready AI coding plugin** providing 20 specialized agents, 65+ skills, 51 commands, and automated hook workflows for software development.
|
|
|
|
## Core Principles
|
|
|
|
1. **Agent-First** — Delegate to specialized agents for domain tasks
|
|
2. **Test-Driven** — Write tests before implementation, 80%+ coverage required
|
|
3. **Security-First** — Never compromise on security; validate all inputs
|
|
4. **Immutability** — Always create new objects, never mutate existing ones
|
|
5. **Plan Before Execute** — Plan complex features before writing code
|
|
|
|
## Available Agents
|
|
|
|
| Agent | Purpose | When to Use |
|
|
|-------|---------|-------------|
|
|
| planner | Implementation planning | Complex features, refactoring |
|
|
| architect | System design and scalability | Architectural decisions |
|
|
| tdd-guide | Test-driven development | New features, bug fixes |
|
|
| code-reviewer | Code quality and maintainability | After writing/modifying code |
|
|
| security-reviewer | Vulnerability detection | Before commits, sensitive code |
|
|
| build-error-resolver | Fix build/type errors | When build fails |
|
|
| e2e-runner | End-to-end Playwright testing | Critical user flows |
|
|
| refactor-cleaner | Dead code cleanup | Code maintenance |
|
|
| doc-updater | Documentation and codemaps | Updating docs |
|
|
| go-reviewer | Go code review | Go projects |
|
|
| go-build-resolver | Go build errors | Go build failures |
|
|
| kotlin-reviewer | Kotlin code review | Kotlin/Android/KMP projects |
|
|
| kotlin-build-resolver | Kotlin/Gradle build errors | Kotlin build failures |
|
|
| database-reviewer | PostgreSQL/Supabase specialist | Schema design, query optimization |
|
|
| python-reviewer | Python code review | Python projects |
|
|
| chief-of-staff | Communication triage and drafts | Multi-channel email, Slack, LINE, Messenger |
|
|
| loop-operator | Autonomous loop execution | Run loops safely, monitor stalls, intervene |
|
|
| harness-optimizer | Harness config tuning | Reliability, cost, throughput |
|
|
| rust-reviewer | Rust code review | Rust projects |
|
|
| rust-build-resolver | Rust build errors | Rust build failures |
|
|
|
|
## Agent Orchestration
|
|
|
|
Use agents proactively without user prompt:
|
|
- Complex feature requests → **planner**
|
|
- Code just written/modified → **code-reviewer**
|
|
- Bug fix or new feature → **tdd-guide**
|
|
- Architectural decision → **architect**
|
|
- Security-sensitive code → **security-reviewer**
|
|
- Multi-channel communication triage → **chief-of-staff**
|
|
- Autonomous loops / loop monitoring → **loop-operator**
|
|
- Harness config reliability and cost → **harness-optimizer**
|
|
|
|
Use parallel execution for independent operations — launch multiple agents simultaneously.
|
|
|
|
## Security Guidelines
|
|
|
|
**Before ANY commit:**
|
|
- No hardcoded secrets (API keys, passwords, tokens)
|
|
- All user inputs validated
|
|
- SQL injection prevention (parameterized queries)
|
|
- XSS prevention (sanitized HTML)
|
|
- CSRF protection enabled
|
|
- Authentication/authorization verified
|
|
- Rate limiting on all endpoints
|
|
- Error messages don't leak sensitive data
|
|
|
|
**Secret management:** NEVER hardcode secrets. Use environment variables or a secret manager. Validate required secrets at startup. Rotate any exposed secrets immediately.
|
|
|
|
**If security issue found:** STOP → use security-reviewer agent → fix CRITICAL issues → rotate exposed secrets → review codebase for similar issues.
|
|
|
|
## Coding Style
|
|
|
|
**Immutability (CRITICAL):** Always create new objects, never mutate. Return new copies with changes applied.
|
|
|
|
**File organization:** Many small files over few large ones. 200-400 lines typical, 800 max. Organize by feature/domain, not by type. High cohesion, low coupling.
|
|
|
|
**Error handling:** Handle errors at every level. Provide user-friendly messages in UI code. Log detailed context server-side. Never silently swallow errors.
|
|
|
|
**Input validation:** Validate all user input at system boundaries. Use schema-based validation. Fail fast with clear messages. Never trust external data.
|
|
|
|
**Code quality checklist:**
|
|
- Functions small (<50 lines), files focused (<800 lines)
|
|
- No deep nesting (>4 levels)
|
|
- Proper error handling, no hardcoded values
|
|
- Readable, well-named identifiers
|
|
|
|
## Testing Requirements
|
|
|
|
**Minimum coverage: 80%**
|
|
|
|
Test types (all required):
|
|
1. **Unit tests** — Individual functions, utilities, components
|
|
2. **Integration tests** — API endpoints, database operations
|
|
3. **E2E tests** — Critical user flows
|
|
|
|
**TDD workflow (mandatory):**
|
|
1. Write test first (RED) — test should FAIL
|
|
2. Write minimal implementation (GREEN) — test should PASS
|
|
3. Refactor (IMPROVE) — verify coverage 80%+
|
|
|
|
Troubleshoot failures: check test isolation → verify mocks → fix implementation (not tests, unless tests are wrong).
|
|
|
|
## Development Workflow
|
|
|
|
1. **Plan** — Use planner agent, identify dependencies and risks, break into phases
|
|
2. **TDD** — Use tdd-guide agent, write tests first, implement, refactor
|
|
3. **Review** — Use code-reviewer agent immediately, address CRITICAL/HIGH issues
|
|
4. **Capture knowledge in the right place**
|
|
- Personal debugging notes, preferences, and temporary context → auto memory
|
|
- Team/project knowledge (architecture decisions, API changes, runbooks) → the project's existing docs structure
|
|
- If the current task already produces the relevant docs or code comments, do not duplicate the same information elsewhere
|
|
- If there is no obvious project doc location, ask before creating a new top-level file
|
|
5. **Commit** — Conventional commits format, comprehensive PR summaries
|
|
|
|
## Git Workflow
|
|
|
|
**Commit format:** `<type>: <description>` — Types: feat, fix, refactor, docs, test, chore, perf, ci
|
|
|
|
**PR workflow:** Analyze full commit history → draft comprehensive summary → include test plan → push with `-u` flag.
|
|
|
|
## Architecture Patterns
|
|
|
|
**API response format:** Consistent envelope with success indicator, data payload, error message, and pagination metadata.
|
|
|
|
**Repository pattern:** Encapsulate data access behind standard interface (findAll, findById, create, update, delete). Business logic depends on abstract interface, not storage mechanism.
|
|
|
|
**Skeleton projects:** Search for battle-tested templates, evaluate with parallel agents (security, extensibility, relevance), clone best match, iterate within proven structure.
|
|
|
|
## Performance
|
|
|
|
**Context management:** Avoid last 20% of context window for large refactoring and multi-file features. Lower-sensitivity tasks (single edits, docs, simple fixes) tolerate higher utilization.
|
|
|
|
**Build troubleshooting:** Use build-error-resolver agent → analyze errors → fix incrementally → verify after each fix.
|
|
|
|
## Project Structure
|
|
|
|
```
|
|
agents/ — 20 specialized subagents
|
|
skills/ — 65+ workflow skills and domain knowledge
|
|
commands/ — 51 slash commands
|
|
hooks/ — Trigger-based automations
|
|
rules/ — Always-follow guidelines (common + per-language)
|
|
scripts/ — Cross-platform Node.js utilities
|
|
mcp-configs/ — 14 MCP server configurations
|
|
tests/ — Test suite
|
|
```
|
|
|
|
## Success Metrics
|
|
|
|
- All tests pass with 80%+ coverage
|
|
- No security vulnerabilities
|
|
- Code is readable and maintainable
|
|
- Performance is acceptable
|
|
- User requirements are met
|