claudekit

claudekit is a toolkit of custom commands, hooks, and utilities designed specifically for Claude Code. It enhances the development workflow by providing reusable prompts, event-driven automation, and specialized AI assistants.

Core Components

• Commands: Slash commands that provide reusable prompts and workflows.
• Hooks: Event-driven automation that runs during development (e.g., TypeScript type checking, ESLint linting).
• Subagents: Specialized AI assistants with deep domain expertise (e.g., webpack-expert, react-expert).

Key Features

• Slash Commands: Commands like /checkpoint:create, /git:status, and /spec:create for common tasks.
• Automated Hooks: Real-time validation for TypeScript, ESLint, and testing.
• AI Subagents: Domain-specific experts for Build Tools, TypeScript, React, Testing, and Infrastructure.

This research report defines the scope of NestJS expertise and identifies the most frequent and complex problems encountered in enterprise Node.js development using NestJS.

Scope: Covers module architecture, dependency injection, decorators, middleware, guards, testing, database integration, and authentication.

High Priority Problem Areas:

• Dependency Injection Resolution: Issues following the "can't resolve dependencies" pattern.
• Circular Dependencies: Critical priority issues involving module loops.
• Testing Module Configuration: Difficulty resolving dependencies within test suites.
• TypeORM/Database Connection Issues: Connection and metadata registration problems.
• JWT Authentication Problems: Errors such as "unknown strategy jwt" and 401 unauthorized responses.

Claudekit provides a suite of specialized git workflow commands designed to optimize AI-assisted development with Claude Code. These commands ensure that branch management, commits, and pushes follow project conventions and include safety checks.

Key commands include:

• /git:checkout: Manages branches using conventional naming.
• /git:commit: Creates commits that follow project-specific conventions.
• /git:push: Performs push operations with built-in pre-flight checks.
• /git:status: Provides detailed status reports with actionable insights.
• /git:ignore-init: Manages .gitignore files specifically for Claude Code projects.

The .claude directory manages configuration for Claude Code. It distinguishes between shared team settings and personal local overrides:

Version Controlled (Commit these)

• .claude/settings.json: Shared team settings for hooks, tools, and environment.
• .claude/commands/*.md: Custom slash commands available to the team.
• .claude/hooks/*.sh: Hook scripts for automated validations (must be executable via chmod +x).

Ignored (Do NOT commit)

• .claude/settings.local.json: Personal preferences and local overrides. This is automatically added to .gitignore by Claude Code.

claudekit operates through three interconnected abstractions that automate and enhance the Claude Code experience:

1. Commands (Slash Commands): These are user-invoked workflows. You trigger them manually in the Claude Code interface to perform specific tasks like generating specifications or creating git checkpoints.
2. Hooks (Automated Hooks): These are reactive. They listen for development events (like file changes) and automatically run validations such as linting or type checking without manual invocation.
3. Subagents (Specialized Assistants): These are task-oriented experts. When a complex domain-specific problem arises, you can invoke a subagent to provide deeper reasoning and specialized knowledge.

All components are designed to be self-contained, project-agnostic, and highly configurable.

The cli-expert agent is a specialist in command-line interface and npm package development. It follows the Unix philosophy and includes automatic project root detection. Use this agent for CLI tool development, npm package creation, argument parsing, and implementing interactive or non-interactive modes.

Available Tools:

• All available tools

When working with NestJS modules, focus on these key areas to ensure a stable architecture:

• Check module structure: Verify that modules are correctly organized and that all necessary providers are declared.
• Identify circular dependencies: Look for modules that depend on each other, which can be mitigated using forwardRef() (though use with caution).
• Debug dependency tokens: Resolve "can't resolve dependencies" errors by verifying that providers are correctly registered in the appropriate modules and that injection tokens match.

Use these patterns to optimize document structure for specific use cases:

• Attribute Pattern: Store varying attributes in key-value pairs to handle heterogeneous data.
• Bucket Pattern: Group time-series data into buckets to improve efficiency and reduce index size.
• Outlier Pattern: Handle exceptional cases (e.g., extremely large documents) separately from normal data to prevent performance degradation.
• Computed Pattern: Pre-calculate and store frequently accessed derived values to avoid expensive runtime calculations.
• Subset Pattern: Keep frequently accessed data in the main document while moving less frequent data to separate collections.