kodit 0.3.0__tar.gz → 0.3.2__tar.gz

kodit-0.3.2/.claude/commands/debug.md

@@ -0,0 +1,121 @@
+# Debug Error Command
+
+Systematically debug and resolve errors in any codebase using a structured approach.
+
+## Instructions
+
+Follow this comprehensive debugging methodology to resolve: **$ARGUMENTS**
+
+1. **Error Information Gathering**
+   - Collect the complete error message, stack trace, and error code
+   - Note when the error occurs (timing, conditions, frequency)
+   - Identify the environment where the error happens (dev, staging, prod)
+   - Gather relevant logs from before and after the error
+
+2. **Reproduce the Error**
+   - Create a minimal test case that reproduces the error consistently
+   - Document the exact steps needed to trigger the error
+   - Test in different environments if possible
+   - Note any patterns or conditions that affect error occurrence
+
+3. **Stack Trace Analysis**
+   - Read the stack trace from bottom to top to understand the call chain
+   - Identify the exact line where the error originates
+   - Trace the execution path leading to the error
+   - Look for any obvious issues in the failing code
+
+4. **Code Context Investigation**
+   - Examine the code around the error location
+   - Check recent changes that might have introduced the bug
+   - Review variable values and state at the time of error
+   - Analyze function parameters and return values
+
+5. **Hypothesis Formation**
+   - Based on evidence, form hypotheses about the root cause
+   - Consider common causes:
+     - Null pointer/undefined reference
+     - Type mismatches
+     - Race conditions
+     - Resource exhaustion
+     - Logic errors
+     - External dependency failures
+
+6. **Debugging Tools Setup**
+   - Set up appropriate debugging tools for the technology stack
+   - Use debugger, profiler, or logging as needed
+   - Configure breakpoints at strategic locations
+   - Set up monitoring and alerting if not already present
+
+7. **Systematic Investigation**
+   - Test each hypothesis methodically
+   - Use binary search approach to isolate the problem
+   - Add strategic logging or print statements
+   - Check data flow and transformations step by step
+
+8. **Data Validation**
+   - Verify input data format and validity
+   - Check for edge cases and boundary conditions
+   - Validate assumptions about data state
+   - Test with different data sets to isolate patterns
+
+9. **Dependency Analysis**
+   - Check external dependencies and their versions
+   - Verify network connectivity and API availability
+   - Review configuration files and environment variables
+   - Test database connections and query execution
+
+10. **Memory and Resource Analysis**
+    - Check for memory leaks or excessive memory usage
+    - Monitor CPU and I/O resource consumption
+    - Analyze garbage collection patterns if applicable
+    - Check for resource deadlocks or contention
+
+11. **Concurrency Issues Investigation**
+    - Look for race conditions in multi-threaded code
+    - Check synchronization mechanisms and locks
+    - Analyze async operations and promise handling
+    - Test under different load conditions
+
+12. **Root Cause Identification**
+    - Once the cause is identified, understand why it happened
+    - Determine if it's a logic error, design flaw, or external issue
+    - Assess the scope and impact of the problem
+    - Consider if similar issues exist elsewhere
+
+13. **Solution Implementation**
+    - Design a fix that addresses the root cause
+    - Consider multiple solution approaches and trade-offs
+    - Implement the fix with appropriate error handling
+    - Add validation and defensive programming where needed
+
+14. **Testing the Fix**
+    - Test the fix against the original error case
+    - Test edge cases and related scenarios
+    - Run regression tests to ensure no new issues
+    - Test under various load and stress conditions
+
+15. **Prevention Measures**
+    - Add appropriate unit and integration tests
+    - Improve error handling and logging
+    - Add input validation and defensive checks
+    - Update documentation and code comments
+
+16. **Monitoring and Alerting**
+    - Set up monitoring for similar issues
+    - Add metrics and health checks
+    - Configure alerts for error thresholds
+    - Implement better observability
+
+17. **Documentation**
+    - Document the error, investigation process, and solution
+    - Update troubleshooting guides
+    - Share learnings with the team
+    - Update code comments with context
+
+18. **Post-Resolution Review**
+    - Analyze why the error wasn't caught earlier
+    - Review development and testing processes
+    - Consider improvements to prevent similar issues
+    - Update coding standards or guidelines if needed
+
+Remember to maintain detailed notes throughout the debugging process and consider the wider implications of both the error and the fix.

kodit-0.3.2/.claude/commands/new-requirement.md

@@ -0,0 +1,534 @@
+# Build Product Requirements Prompt
+
+## Instructions
+
+Create a comprehensive Product Requirement Prompt (PRP) with user-centered requirements gathering for: **$ARGUMENTS**
+
+## Intelligent Workflow Selection
+
+**Analyze `$ARGUMENTS` complexity and choose approach:**
+
+- **Simple/Clear Request** (e.g., "add a login button"): Skip to Phase 3 (Research & PRP Generation)
+- **Moderate Request** (e.g., "user authentication system"): Start with Phase 2 (Targeted Questions)
+- **Complex/Vague Request** (e.g., "improve user experience"): Start with Phase 1 (Discovery)
+
+## Full Workflow
+
+### Phase 1: Discovery Questions (Complex/Vague Requests Only)
+
+Ask 5 strategic discovery questions to understand the problem space:
+
+```markdown
+I need to understand the broader context first. Let me ask 5 key questions:
+
+## Discovery Questions
+
+**Q1: Will users interact with this feature through a visual interface?**
+Default: Yes (most features have UI components)
+
+**Q2: Does this involve user data or require authentication?**
+Default: Yes (better to plan for security)
+
+**Q3: Do users currently have a workaround for this problem?**
+Default: No (assuming this solves a new need)
+
+**Q4: Will this need to integrate with external services or APIs?**
+Default: No (simpler implementation)
+
+**Q5: Is this a completely new feature or an enhancement to existing functionality?**
+Default: Enhancement (most requests build on existing features)
+
+*You can answer any/all questions or just say "continue" to use the defaults.*
+```
+
+### Phase 2: Technical Context Questions (Moderate+ Requests)
+
+Ask 5 targeted technical questions informed by codebase analysis:
+
+```markdown
+Now let me ask about technical implementation details:
+
+## Technical Questions
+
+**Q6: [Specific question about existing similar features/components]**
+Default: [Codebase-informed default]
+
+**Q7: [Question about data layer/database requirements]**
+Default: [Pattern-based default]
+
+**Q8: [Question about API/service layer approach]**
+Default: [Architecture-consistent default]
+
+**Q9: [Question about testing/validation approach]**
+Default: [Project-standard default]
+
+**Q10: [Question about deployment/configuration needs]**
+Default: [Environment-appropriate default]
+
+*Answer what you know, or say "continue" for smart defaults based on your codebase.*
+```
+
+### Phase 3: Research & Context Gathering
+
+**Automatically perform comprehensive research:**
+
+1. **Web Research** (when beneficial):
+   - Research best practices and current standards
+   - Look up relevant library/framework documentation using mcp__kodit__search (if available)
+   - Find example implementations and patterns using mcp__kodit__search (if available)
+   - Gather security and performance considerations
+
+2. **Codebase Analysis** (when tools available):
+   - Analyze overall architecture and patterns
+   - Identify similar existing features using mcp__kodit__search (if available)
+   - Understand technology stack and conventions
+   - Find integration points and dependencies
+
+3. **Technical Context**:
+   - Identify affected files and components
+   - Understand data flow and business logic
+   - Map out user interactions and workflows
+   - Document technical constraints and opportunities
+
+### Phase 4: Generate Comprehensive PRP
+
+Create a complete Product Requirement Prompt that combines user requirements with
+implementation guidance. Use the following template to create a new markdown file in
+docs/requirements/YYYY-MM-DD-HHMM-[slug].md, where `[slug]` is a slug extracted from the
+requirement and `YYYY-MM-DD-HHMM` is parsed from the system's `date` command.
+
+---
+
+## PRP Output Template
+
+```markdown
+# Product Requirement Prompt: [Feature Name]
+
+**Generated:** [timestamp]  
+**Original Request:** $ARGUMENTS  
+**Complexity Level:** [Simple/Moderate/Complex]  
+**Questions Asked:** [X/10]  
+
+## Executive Summary
+
+### Goal
+[Concise statement of what this PRP aims to achieve based on discovery]
+
+### Why
+- **Business Value:** [Based on user needs discovered]
+- **User Benefits:** [Who benefits and how]
+- **Technical Benefits:** [System improvements]
+- **Strategic Alignment:** [How it fits with existing functionality]
+
+### What
+**Core Functionality:**
+[Detailed explanation based on all gathered context including:]
+- Primary features and capabilities
+- User interaction patterns
+- System behaviors and rules
+- Integration requirements
+- Scope and boundaries
+
+## Requirements Analysis
+
+### User Requirements Summary
+[Synthesis of discovery answers and user needs]
+
+### Technical Requirements Summary  
+[Synthesis of technical context and codebase analysis]
+
+### Key Decisions Made
+- [Decision 1]: [Reasoning based on questions/research]
+- [Decision 2]: [Reasoning based on questions/research]
+- [Decision 3]: [Reasoning based on questions/research]
+
+## Architecture & Implementation
+
+### Technical Overview
+- **Architecture Pattern:** [Based on codebase analysis]
+- **Technology Stack:** [Current stack + any additions needed]
+- **Integration Points:** [Internal and external connections]
+- **Data Flow:** [How information moves through the system]
+
+### Directory Structure
+
+**Current Relevant Structure:**
+```
+
+[Tree representation of current relevant files/directories]
+
+```
+
+**Proposed Changes:**
+```
+
+[Tree showing new/modified files with descriptions]
+├── [existing_dir]/
+│   ├── [existing_file.ext]
+│   ├── [new_file.ext] - [purpose and contents description]
+│   └── [modified_file.ext] - [changes needed]
+
+```
+
+### Files to Reference
+- **[file_path]** (existing) - [How to use as reference/pattern]
+- **[documentation_url]** (external) - [Relevant sections for implementation]
+- **[similar_feature_path]** (existing) - [Pattern to follow/extend]
+- **[library_docs_url]** (external) - [Specific methods/approaches to use]
+
+### Implementation Specifications
+
+#### [Component Category 1: e.g., Data Layer]
+**File: `[file_path]`**
+Purpose: [Specific role in the implementation]
+
+```[language]
+[Sample code structure or key implementation patterns]
+// Key considerations:
+// - [Specific requirement from discovery]
+// - [Pattern to follow from codebase]
+// - [Best practice from research]
+```
+
+#### [Component Category 2: e.g., Business Logic]
+
+**File: `[file_path]`**
+Purpose: [Specific role in the implementation]
+
+```[language]
+[Sample code structure or key implementation patterns]
+// Key considerations:
+// - [User requirement addressed]
+// - [Integration with existing systems]
+// - [Error handling patterns]
+```
+
+#### [Component Category 3: e.g., User Interface]
+
+**File: `[file_path]`**
+Purpose: [Specific role in the implementation]
+
+```[language]
+[Sample code structure or key implementation patterns]
+// Key considerations:
+// - [User experience requirements]
+// - [Accessibility standards]
+// - [Responsive design needs]
+```
+
+## API/Endpoints Design
+
+### [Endpoint 1]
+
+- **Method:** [GET/POST/PUT/DELETE]
+- **Path:** [/api/path]
+- **Purpose:** [What this endpoint accomplishes]
+- **Parameters:**
+  - `param1` (type) - [description]
+  - `param2` (type) - [description]
+- **Success Response:**
+
+  ```json
+  [Example response structure]
+  ```
+
+- **Error Handling:** [Specific error cases and responses]
+
+### [Endpoint 2]
+
+[Similar structure for additional endpoints]
+
+## Implementation Guidelines
+
+### [Technical Domain 1: e.g., Authentication & Security]
+
+**Requirements from Discovery:**
+
+- [Specific security requirement from questions]
+- [User data protection needs]
+
+**Implementation Approach:**
+
+- [Specific security patterns to follow]
+- [Authentication/authorization strategy]
+- [Data validation and sanitization]
+- [Error handling for security scenarios]
+
+**Code References:**
+
+- Follow patterns in `[existing_auth_file]`
+- Use security helpers from `[security_utils_file]`
+
+### [Technical Domain 2: e.g., Data Management]
+
+**Requirements from Discovery:**
+
+- [Data persistence needs]
+- [Performance requirements]
+
+**Implementation Approach:**
+
+- [Database/storage strategy]
+- [Data validation rules]
+- [Performance optimization techniques]
+- [Backup and recovery considerations]
+
+**Code References:**
+
+- Extend patterns from `[existing_data_layer]`
+- Use ORM/database helpers from `[db_utils_file]`
+
+### [Technical Domain 3: e.g., User Experience]
+
+**Requirements from Discovery:**
+
+- [UI/UX requirements from questions]
+- [Accessibility needs]
+
+**Implementation Approach:**
+
+- [User interface design principles]
+- [Interaction patterns to follow]
+- [Responsive design requirements]
+- [Error messaging and feedback]
+
+**Code References:**
+
+- Follow component patterns in `[ui_components_dir]`
+- Use styling conventions from `[styles_dir]`
+
+## Validation & Testing Strategy
+
+### Functional Validation
+
+**Based on User Requirements:**
+
+- [ ] [Specific user workflow works as expected]
+- [ ] [User interaction produces correct results]
+- [ ] [Error scenarios are handled gracefully]
+
+**Test Commands:**
+
+```bash
+[Specific test commands for functional validation]
+```
+
+### Technical Validation
+
+**Based on Technical Requirements:**
+
+- [ ] [Performance benchmark met: response < Xms]
+- [ ] [Security standard implemented: authentication required]
+- [ ] [Integration working: external API connection established]
+
+**Test Commands:**
+
+```bash
+[Specific test commands for technical validation]
+```
+
+### User Acceptance Criteria
+
+**Derived from Discovery Questions:**
+
+- [ ] [Acceptance criterion based on Q1 answer]
+- [ ] [Acceptance criterion based on Q2 answer]
+- [ ] [Acceptance criterion based on Q3 answer]
+- [ ] [Overall user satisfaction metric]
+
+## Implementation Roadmap
+
+### Checkpoint 1: Foundation Setup
+
+**Tasks:**
+
+- [ ] Set up basic project structure
+- [ ] Implement core data models
+- [ ] Create basic authentication framework
+
+**Validation:**
+
+```bash
+[Test command to verify foundation]
+```
+
+**Expected:** [Specific expected outcome]
+
+### Checkpoint 2: Core Feature Implementation
+
+**Tasks:**
+
+- [ ] Implement primary business logic
+- [ ] Create user interface components
+- [ ] Set up API endpoints
+
+**Validation:**
+
+```bash
+[Test command to verify core features]
+```
+
+**Expected:** [Specific expected outcome]
+
+### Checkpoint 3: Integration & Polish
+
+**Tasks:**
+
+- [ ] Integrate with existing systems
+- [ ] Implement error handling and edge cases
+- [ ] Performance optimization and testing
+
+**Validation:**
+
+```bash
+[Test command to verify complete implementation]
+```
+
+**Expected:** [Specific expected outcome]
+
+## Research References
+
+### Best Practices Sources
+
+- [URL/Resource 1]: [Key insights relevant to implementation]
+- [URL/Resource 2]: [Specific techniques or patterns found]
+- [URL/Resource 3]: [Standards or conventions to follow]
+
+### Technical Documentation
+
+- [Library/Framework Docs]: [Specific sections relevant to implementation]
+- [API Documentation]: [Integration details and examples]
+- [Security Guidelines]: [Relevant security considerations]
+
+### Example Implementations
+
+- [GitHub/StackOverflow URL]: [Pattern or approach to reference]
+- [Code Example URL]: [Specific implementation technique]
+- [Tutorial/Guide URL]: [Step-by-step process to follow]
+
+## Risk Assessment & Mitigation
+
+### Technical Risks
+
+- **Risk:** [Potential technical challenge]
+  **Likelihood:** [High/Medium/Low]
+  **Impact:** [High/Medium/Low]  
+  **Mitigation:** [Specific strategy to address]
+
+### Business Risks
+
+- **Risk:** [Potential business/user impact]
+  **Likelihood:** [High/Medium/Low]
+  **Impact:** [High/Medium/Low]
+  **Mitigation:** [Specific strategy to address]
+
+### Dependencies & Assumptions
+
+**External Dependencies:**
+
+- [Dependency 1]: [Version and reliability considerations]
+- [Dependency 2]: [Integration complexity and fallback options]
+
+**Key Assumptions:**
+
+- [ASSUMED]: [Assumption based on unanswered questions]
+- [ASSUMED]: [Technical assumption based on codebase patterns]
+- [ASSUMED]: [Business assumption based on discovery defaults]
+
+## Success Metrics & Monitoring
+
+### Key Performance Indicators
+
+- **[Metric 1]:** [Target value] - [How to measure]
+- **[Metric 2]:** [Target value] - [How to measure]  
+- **[Metric 3]:** [Target value] - [How to measure]
+
+### Monitoring Strategy
+
+- [What to track automatically]
+- [User feedback collection methods]
+- [Performance monitoring approach]
+- [Error tracking and alerting]
+
+### Success Definition
+
+**MVP Success:**
+
+- [ ] [Minimum viable implementation criteria]
+- [ ] [Basic user satisfaction threshold]
+- [ ] [Technical performance baseline]
+
+**Full Success:**
+
+- [ ] [Complete feature functionality]
+- [ ] [Optimal user experience metrics]
+- [ ] [Technical excellence standards]
+
+---
+
+## Quick Implementation Guide
+
+### Getting Started (Copy/Paste Ready)
+
+```bash
+# 1. Set up development environment
+[Specific setup commands based on tech stack]
+
+# 2. Create basic structure  
+[Commands to create necessary directories/files]
+
+# 3. Implement core logic
+[Key implementation steps in order]
+
+# 4. Test implementation
+[Test commands to verify each step]
+```
+
+### Code Patterns to Follow
+
+**Pattern 1: [Name]**
+
+```[language]
+// Location: [existing_file_reference]
+[Code example showing pattern to follow]
+```
+
+**Pattern 2: [Name]**  
+
+```[language]
+// Location: [existing_file_reference]
+[Code example showing pattern to follow]
+```
+
+### Common Pitfalls & Solutions
+
+- **Pitfall:** [Common mistake in this type of implementation]
+  **Solution:** [Specific approach to avoid the mistake]
+  **Example:** [Code or configuration example]
+
+```
+
+## Execution Strategy
+
+### Request Analysis
+1. **Parse `$ARGUMENTS`** for complexity indicators:
+   - **Simple:** Contains specific technical terms, clear scope
+   - **Moderate:** General feature description with some context  
+   - **Complex:** Vague goals, broad scope, unclear requirements
+
+2. **Determine Question Strategy:**
+   - **Simple:** Skip to research and generation
+   - **Moderate:** Ask 5 technical questions only
+   - **Complex:** Ask all 10 questions (5 discovery + 5 technical)
+
+### Research Integration
+- **Always perform web research** for best practices and standards
+- **Use codebase tools when available** for context and patterns
+- **Synthesize findings** into actionable implementation guidance
+- **Provide concrete examples** and reference materials
+
+### Output Quality Assurance
+- **Ensure actionability:** Every section should be implementable
+- **Maintain specificity:** Use actual file paths, concrete examples
+- **Balance comprehensiveness with clarity:** Cover all aspects without overwhelming
+- **Validate completeness:** Check that PRP provides sufficient context for implementation

kodit-0.3.2/.claude/commands/refactor.md

@@ -0,0 +1,33 @@
+# Refactor Code Command
+
+Safely improve code structure while preserving functionality.
+
+## Core Principles
+
+- **Test First**: Ensure tests exist and pass before starting
+- **Small Steps**: Make incremental changes, test after each
+- **Preserve Behavior**: External functionality must remain identical
+
+## Refactoring Process
+
+1. **Analyze** - Understand current code and identify improvement areas
+2. **Test Coverage** - Verify/add tests before changing anything
+3. **Plan** - Choose refactoring technique (extract method, rename, simplify conditionals)
+4. **Execute** - Make one small change at a time, running tests after each
+5. **Verify** - Ensure all tests pass and performance hasn't degraded
+
+## Key Improvements
+
+- **Clarity**: Better names, simpler logic, shorter methods
+- **Structure**: Remove duplication, improve separation of concerns, improve cohesion
+- **Maintainability**: Apply patterns where beneficial, standardize error handling
+- **Documentation**: Update comments and docs to match changes
+
+## Safety Checklist
+
+- [ ] All tests passing before and after
+- [ ] No functionality changes
+- [ ] Code reviewed for quality
+- [ ] Changes documented
+
+Remember: Working code > perfect code. Commit frequently, refactor incrementally.

kodit-0.3.2/.claude/settings.json

@@ -0,0 +1,3 @@
+{
+    "includeCoAuthoredBy": false
+}