This project integrates several development tools—Husky, Kiro hooks, ESLint, Prettier, and markdownlint—to automate and enforce code quality, formatting, and documentation standards throughout the development workflow. These tools work together via Git hooks, Kiro agent automation, and shared configuration to ensure consistency and reduce manual review effort.

Tool Roles and Integration#

Husky manages Git hooks, specifically pre-commit and pre-push scripts, to automate checks and formatting before code is committed or pushed. The .husky directory contains these scripts, which invoke linting, formatting, type checking, and tests as part of the workflow. Husky ensures that code quality gates are enforced at critical points in the Git lifecycle, preventing substandard code from entering the repository [PR #8].

Kiro hooks are defined in .kiro/hooks and provide additional automation. They trigger on file save, source code changes, and documentation edits. For example, the format-on-save hook runs just format whenever a relevant file is saved, ensuring immediate code formatting. Other Kiro hooks prompt for documentation updates when source files change, and automatically update the llms.txt file when documentation files are edited, keeping documentation synchronized with code changes [format-on-save.kiro.hook] [docs-sync-on-source-change.kiro.hook] [update-llms-txt.kiro.hook].

ESLint enforces code quality and style rules for JavaScript and TypeScript, with configurations for React and integration with Prettier. It is run as part of the linting process before commits and pushes, ensuring that code adheres to project standards [eslint.config.mjs].

Prettier is the code formatter, configured to enforce consistent style across the codebase. It runs both as a pre-commit hook (formatting staged files) and via Kiro hooks on file save, so code is always formatted before being committed or pushed [.prettierrc.json].

markdownlint checks Markdown files for style and consistency issues, using a project-specific configuration. It is included in the automated workflow to ensure documentation quality [.markdownlint-cli2.jsonc].

Workflow Automation#

The integration of these tools creates a layered, automated workflow:

• On file save: Kiro's format-on-save hook runs just format, which invokes Prettier (and potentially markdownlint) on relevant files, ensuring immediate formatting.
• On code commit (git commit): Husky's pre-commit hook (or pre-commit framework) runs Prettier on staged files, ESLint for linting, and TypeScript for type checking. This prevents commits with formatting, linting, or type errors.
• On code push (git push): Husky's pre-push hook runs type checking across all workspaces and executes all test suites, blocking pushes if any checks fail.
• On documentation or source changes: Kiro hooks monitor for changes to source files and documentation. When triggered, they prompt for documentation updates (e.g., README, /docs, API specs) and update llms.txt to keep documentation in sync with code changes.

This process is illustrated below:

Configuration and Usage Guidance#

• Setup: Run the setup script or use the justfile commands to install dependencies and hooks. For example, just setup or just install-hooks will install pre-commit hooks and any additional Git hooks required by Husky and Kiro [justfile].
• Pre-commit and pre-push hooks: These are managed by Husky and/or the pre-commit framework. They run formatting, linting, type checking, and tests automatically. You can update hooks with pre-commit autoupdate or just update-deps [CONTRIBUTING.md].
• Kiro hooks: These are configured in .kiro/hooks and run automatically based on file events. No manual intervention is needed; they ensure formatting and documentation synchronization as you work.
• Linting and formatting: Use npm run lint and npm run format (or the corresponding just commands) to manually lint or format the codebase.
• Documentation standards: markdownlint enforces Markdown style rules, and Kiro hooks prompt for documentation updates when code changes may affect docs.

Best Practices#

• Always allow hooks to run; skipping them is discouraged except in emergencies.
• Run tests and linting before committing.
• Use descriptive commit messages following the conventional commits standard.
• Keep dependencies and hooks updated to ensure consistency across contributors.

This integrated workflow ensures that code quality, formatting, and documentation standards are enforced automatically at every stage of development, reducing manual review effort and maintaining a high standard across the project.