kodit 0.3.1__tar.gz → 0.3.2__tar.gz

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.1 → kodit-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kodit
-Version: 0.3.1
+Version: 0.3.2
 Summary: Code indexing for better AI code generation
 Project-URL: Homepage, https://docs.helixml.tech/kodit/
 Project-URL: Documentation, https://docs.helixml.tech/kodit/

{kodit-0.3.1 → kodit-0.3.2}/src/kodit/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.3.1'
-__version_tuple__ = version_tuple = (0, 3, 1)
+__version__ = version = '0.3.2'
+__version_tuple__ = version_tuple = (0, 3, 2)

{kodit-0.3.1 → kodit-0.3.2}/src/kodit/application/services/code_indexing_application_service.py

@@ -157,7 +157,7 @@ class CodeIndexingApplicationService:
             snippet_results = await self.snippet_domain_service.search_snippets(
                 prefilter_request
             )
-            filtered_snippet_ids = [snippet.id for snippet in snippet_results]
+            filtered_snippet_ids = [snippet.snippet.id for snippet in snippet_results]
 
         # Gather results from different search modes
         fusion_list: list[list[FusionRequest]] = []
@@ -225,9 +225,20 @@ class CodeIndexingApplicationService:
         return [
             MultiSearchResult(
                 id=result.snippet.id,
-                uri=result.file.uri,
                 content=result.snippet.content,
                 original_scores=fr.original_scores,
+                # Enhanced fields
+                source_uri=result.source.uri,
+                relative_path=MultiSearchResult.calculate_relative_path(
+                    result.file.cloned_path, result.source.cloned_path
+                ),
+                language=MultiSearchResult.detect_language_from_extension(
+                    result.file.extension
+                ),
+                authors=[author.name for author in result.authors],
+                created_at=result.snippet.created_at,
+                # Summary from snippet entity
+                summary=result.snippet.summary,
             )
             for result, fr in zip(search_results, final_results, strict=True)
         ]
@@ -300,16 +311,8 @@ class CodeIndexingApplicationService:
         async for result in self.enrichment_service.enrich_documents(
             enrichment_request
         ):
-            # Update snippet content through domain service
-            enriched_content = (
-                result.text
-                + "\n\n```\n"
-                + next(s.content for s in snippets if s.id == result.snippet_id)
-                + "\n```"
-            )
-
-            await self.snippet_domain_service.update_snippet_content(
-                result.snippet_id, enriched_content
+            await self.snippet_domain_service.update_snippet_summary(
+                result.snippet_id, result.text
             )
 
             processed += 1