Libragent Quality

LibrAgent Code Quality Validation

This skill provides comprehensive code quality validation for the LibrAgent project, which uses a dual-stack architecture with React/TypeScript frontend and Rust/Tauri backend.

Quick Start

For complete validation before commits or PRs:

pnpm refactor:validate

This runs all checks in sequence and ensures code quality across the entire stack.

Individual Validation Commands

Frontend (TypeScript/React)

# Linting - Check code style and potential errors
pnpm lint

# Format checking
pnpm format:check

# Auto-fix formatting issues
pnpm format

# Type checking and build
pnpm build

# Dead code detection
pnpm dead-code

# Run tests
pnpm test:run

Backend (Rust)

# Format checking
pnpm rust:fmt:check

# Auto-format Rust code
pnpm rust:fmt

# Lint with clippy
pnpm rust:clippy

# Type checking
pnpm rust:check

# Check with all features
pnpm rust:check:all

# Run tests
pnpm rust:test

# Complete Rust validation
pnpm rust:validate

Complete Validation Pipeline

The refactor:validate command executes:

1. ESLint - JavaScript/TypeScript code quality
2. Prettier - Code formatting consistency
3. Vitest - Test suite execution
4. Rust fmt - Rust code formatting
5. Rust clippy - Rust linting
6. Rust check - Rust compilation check with all features
7. Rust test - Rust test suite
8. Vite build - Production build verification
9. Unimported - Unused code detection

Common Validation Scenarios

Before Committing

pnpm refactor:validate

Wait for all checks to pass. Fix any errors reported.

Quick Frontend Check

pnpm lint && pnpm format && pnpm build

Quick Backend Check

pnpm rust:validate

Fix Formatting Issues

# Fix frontend formatting
pnpm format

# Fix Rust formatting
pnpm rust:fmt

Critical Project Rules

TypeScript Rules

1. Never use any - Use precise types, unknown with type guards, or generics
2. No ESLint-disable comments - Fix the underlying issue instead
3. Use centralized logger - getLogger('ComponentName') not console.*
4. No inline import types - Use proper import statements at top of file

Rust Rules

1. Use rustfmt - Always format before committing
2. Fix clippy warnings - No warnings allowed (-D warnings in CI)
3. Handle errors explicitly - Use Result<T, E> types
4. Document public APIs - Use /// doc comments

Architecture Rules

1. Feature-based organization - Components in src/features/
2. Service layer pattern - Business logic in src/lib/
3. Compound components - Use patterns like Chat.Header, Chat.Messages
4. Type safety - Define interfaces in src/models/

Troubleshooting

ESLint Errors

Check .eslintrc.js or eslint.config.js for rules. Fix code to match standards.

Prettier Conflicts

Run pnpm format to auto-fix formatting issues.

Rust Clippy Warnings

Read clippy suggestions carefully - they often indicate actual bugs or improvements.

Build Failures

1. Check TypeScript errors: tsc --noEmit
2. Check Rust errors: cd src-tauri && cargo check
3. Verify dependencies: pnpm install

Dead Code Detection

Review unimported output. Remove unused exports or add to ignore list if intentional.

Integration with CI/CD

The project uses GitHub Actions for CI. All validation commands must pass before merge:

• ESLint must pass
• Prettier formatting must be correct
• TypeScript must compile without errors
• Rust must compile without warnings
• All tests must pass
• No dead code (with approved exceptions)

Best Practices

1. Run validation early and often - Don't wait until PR time
2. Fix issues incrementally - Easier to debug when changes are small
3. Read error messages carefully - They often contain the solution
4. Keep tests passing - Don't commit broken tests
5. Document exceptions - If you must disable a rule, explain why

Reference

For detailed project guidelines, see:

• .github/copilot-instructions.md - Complete coding standards
• agents.md - Agent-specific guidelines
• docs/architecture/ - Architecture documentation
• CONTRIBUTING.md - Contribution guidelines

Converted and distributed by TomeVault — claim your Tome and manage your conversions.