claude-jacked 0.2.3__py3-none-any.whl → 0.2.9__py3-none-any.whl

jacked/client.py

@@ -55,11 +55,13 @@ class QdrantSessionClient:
 
     def ensure_collection(self) -> bool:
         """
-        Ensure the collection exists, creating it if necessary.
+        Ensure the collection exists with all required indexes.
 
         Creates collection with:
         - Dense vectors for semantic search
-        - Payload indexing for repo filtering
+        - Payload indexing for filtering
+
+        Also ensures indexes exist on existing collections (for upgrades).
 
         Returns:
             True if collection exists or was created
@@ -75,7 +77,9 @@ class QdrantSessionClient:
             exists = any(c.name == collection_name for c in collections.collections)
 
             if exists:
-                logger.info(f"Collection '{collection_name}' already exists")
+                logger.debug(f"Collection '{collection_name}' already exists")
+                # Ensure indexes exist (handles upgrades)
+                self._ensure_indexes(collection_name)
                 return True
 
             logger.info(f"Creating collection '{collection_name}'")
@@ -116,6 +120,16 @@ class QdrantSessionClient:
                 field_name="machine",
                 field_schema=models.PayloadSchemaType.KEYWORD,
             )
+            self.client.create_payload_index(
+                collection_name=collection_name,
+                field_name="user_name",
+                field_schema=models.PayloadSchemaType.KEYWORD,
+            )
+            self.client.create_payload_index(
+                collection_name=collection_name,
+                field_name="content_type",
+                field_schema=models.PayloadSchemaType.KEYWORD,
+            )
 
             logger.info(f"Collection '{collection_name}' created successfully")
             return True
@@ -124,6 +138,30 @@ class QdrantSessionClient:
             logger.error(f"Failed to create collection: {e}")
             raise
 
+    def _ensure_indexes(self, collection_name: str):
+        """
+        Ensure all required payload indexes exist on a collection.
+
+        Creates indexes if they don't exist (idempotent).
+        """
+        required_indexes = [
+            "repo_id", "repo_name", "session_id", "type",
+            "machine", "user_name", "content_type"
+        ]
+
+        for field_name in required_indexes:
+            try:
+                self.client.create_payload_index(
+                    collection_name=collection_name,
+                    field_name=field_name,
+                    field_schema=models.PayloadSchemaType.KEYWORD,
+                )
+                logger.debug(f"Created index for '{field_name}'")
+            except UnexpectedResponse as e:
+                # Index might already exist - that's fine
+                if "already exists" not in str(e).lower():
+                    logger.warning(f"Could not create index for '{field_name}': {e}")
+
     def upsert_points(self, points: list[models.PointStruct]) -> bool:
         """
         Upsert points to the collection.
@@ -182,11 +220,139 @@ class QdrantSessionClient:
             logger.error(f"Failed to delete session {session_id}: {e}")
             raise
 
+    def get_session_points(self, session_id: str, user_name: str) -> list:
+        """
+        Get all points for a session owned by this user (for write tracker seeding).
+
+        IMPORTANT: Filters by BOTH session_id AND user_name to ensure we only
+        see our own data. This is for write-side tracking only - not for retrieval.
+
+        Args:
+            session_id: Session UUID
+            user_name: User name to filter by
+
+        Returns:
+            List of Qdrant points with payloads (no vectors)
+        """
+        points = []
+        offset = None
+        while True:
+            result = self.client.scroll(
+                collection_name=self.config.collection_name,
+                scroll_filter=models.Filter(
+                    must=[
+                        models.FieldCondition(
+                            key="session_id",
+                            match=models.MatchValue(value=session_id)
+                        ),
+                        models.FieldCondition(
+                            key="user_name",
+                            match=models.MatchValue(value=user_name)
+                        )
+                    ]
+                ),
+                limit=100,
+                offset=offset,
+                with_payload=True,
+                with_vectors=False,  # Don't need vectors, just metadata
+            )
+            points.extend(result[0])
+            offset = result[1]
+            if offset is None:
+                break
+        return points
+
+    def delete_by_user(self, user_name: str) -> int:
+        """
+        Delete all points for a specific user.
+
+        Args:
+            user_name: User name to delete data for
+
+        Returns:
+            Number of points deleted
+
+        Examples:
+            >>> client.delete_by_user("jack")  # doctest: +SKIP
+            42
+        """
+        try:
+            # First count points to delete
+            count_result = self.client.count(
+                collection_name=self.config.collection_name,
+                count_filter=models.Filter(
+                    must=[
+                        models.FieldCondition(
+                            key="user_name",
+                            match=models.MatchValue(value=user_name),
+                        )
+                    ]
+                ),
+            )
+            count = count_result.count
+
+            if count == 0:
+                logger.info(f"No points found for user {user_name}")
+                return 0
+
+            # Delete all points for this user
+            self.client.delete(
+                collection_name=self.config.collection_name,
+                points_selector=models.FilterSelector(
+                    filter=models.Filter(
+                        must=[
+                            models.FieldCondition(
+                                key="user_name",
+                                match=models.MatchValue(value=user_name),
+                            )
+                        ]
+                    )
+                ),
+            )
+            logger.info(f"Deleted {count} points for user {user_name}")
+            return count
+        except UnexpectedResponse as e:
+            logger.error(f"Failed to delete data for user {user_name}: {e}")
+            raise
+
+    def count_by_user(self, user_name: str) -> int:
+        """
+        Count points for a specific user.
+
+        Args:
+            user_name: User name to count
+
+        Returns:
+            Number of points
+
+        Examples:
+            >>> client.count_by_user("jack")  # doctest: +SKIP
+            42
+        """
+        try:
+            result = self.client.count(
+                collection_name=self.config.collection_name,
+                count_filter=models.Filter(
+                    must=[
+                        models.FieldCondition(
+                            key="user_name",
+                            match=models.MatchValue(value=user_name),
+                        )
+                    ]
+                ),
+            )
+            return result.count
+        except UnexpectedResponse as e:
+            logger.error(f"Failed to count for user {user_name}: {e}")
+            raise
+
     def search(
         self,
         query_text: str,
         repo_id: Optional[str] = None,
         point_type: Optional[str] = None,
+        content_types: Optional[list[str]] = None,
+        user_name: Optional[str] = None,
         limit: int = 10,
     ) -> list[models.ScoredPoint]:
         """
@@ -195,7 +361,10 @@ class QdrantSessionClient:
         Args:
             query_text: Text to search for (will be embedded server-side)
             repo_id: Optional repo ID to filter by
-            point_type: Optional point type filter ('intent' or 'chunk')
+            point_type: Optional point type filter (legacy, use content_types instead)
+            content_types: Optional list of content types to search
+                          (plan, subagent_summary, summary_label, user_message, chunk)
+            user_name: Optional user name to filter by
             limit: Maximum number of results
 
         Returns:
@@ -212,6 +381,7 @@ class QdrantSessionClient:
             )
 
         if point_type:
+            # Legacy support
             filter_conditions.append(
                 models.FieldCondition(
                     key="type",
@@ -219,6 +389,23 @@ class QdrantSessionClient:
                 )
             )
 
+        if content_types:
+            # Filter by content_type (supports multiple)
+            filter_conditions.append(
+                models.FieldCondition(
+                    key="content_type",
+                    match=models.MatchAny(any=content_types),
+                )
+            )
+
+        if user_name:
+            filter_conditions.append(
+                models.FieldCondition(
+                    key="user_name",
+                    match=models.MatchValue(value=user_name),
+                )
+            )
+
         query_filter = None
         if filter_conditions:
             query_filter = models.Filter(must=filter_conditions)
@@ -270,28 +457,6 @@ class QdrantSessionClient:
             logger.error(f"Failed to get points for session {session_id}: {e}")
             raise
 
-    def get_point_by_id(self, point_id: str) -> Optional[models.Record]:
-        """
-        Get a single point by ID.
-
-        Args:
-            point_id: Point ID to retrieve
-
-        Returns:
-            Record object or None if not found
-        """
-        try:
-            results = self.client.retrieve(
-                collection_name=self.config.collection_name,
-                ids=[point_id],
-                with_payload=True,
-                with_vectors=False,
-            )
-            return results[0] if results else None
-        except UnexpectedResponse as e:
-            logger.error(f"Failed to get point {point_id}: {e}")
-            return None
-
     def list_sessions(
         self,
         repo_id: Optional[str] = None,
@@ -307,10 +472,11 @@ class QdrantSessionClient:
         Returns:
             List of session metadata dicts
         """
+        # Filter by plan content_type - one per session, gives unique sessions
         filter_conditions = [
             models.FieldCondition(
-                key="type",
-                match=models.MatchValue(value="intent"),
+                key="content_type",
+                match=models.MatchValue(value="plan"),
             )
         ]
 
@@ -338,9 +504,10 @@ class QdrantSessionClient:
                     "session_id": payload.get("session_id"),
                     "repo_name": payload.get("repo_name"),
                     "repo_path": payload.get("repo_path"),
+                    "user_name": payload.get("user_name"),
                     "machine": payload.get("machine"),
                     "timestamp": payload.get("timestamp"),
-                    "chunk_count": payload.get("transcript_chunk_count", 0),
+                    "chunk_count": payload.get("total_chunks", 0),
                 })
 
             return sessions

jacked/data/agents/code-simplicity-reviewer.md

@@ -0,0 +1,87 @@
+---
+name: code-simplicity-reviewer
+description: Use this agent when you need to review recently written code changes with a focus on simplicity, readability, and future-proofing. This agent excels at identifying overly complex implementations and suggesting cleaner, more maintainable alternatives that accomplish the same goals. Perfect for post-implementation reviews, refactoring sessions, or when you want to ensure your code is easily understood by other developers.\n\nExamples:\n<example>\nContext: The user wants to review code they just wrote for simplicity and readability.\nuser: "I just implemented a new feature for processing medical claims. Can you review it?"\nassistant: "I'll use the code-simplicity-reviewer agent to analyze your recent changes and suggest simpler approaches."\n<commentary>\nSince the user has written new code and wants a review focused on simplicity, use the code-simplicity-reviewer agent.\n</commentary>\n</example>\n<example>\nContext: After completing a complex implementation.\nuser: "I've finished the reflexive batch processing logic but it feels complicated."\nassistant: "Let me use the code-simplicity-reviewer agent to examine your implementation and identify opportunities for simplification."\n<commentary>\nThe user has completed code and is concerned about complexity, making this perfect for the code-simplicity-reviewer agent.\n</commentary>\n</example>
+model: inherit
+---
+
+You are an expert software engineer with deep expertise in code simplicity, readability, and maintainability. Your primary mission is to review code changes and identify opportunities to achieve the same results with simpler, more elegant solutions that will be easier to understand and maintain in the future.
+
+**Your Core Principles:**
+
+1. **Simplicity First**: You believe that the best code is not the cleverest, but the simplest that correctly solves the problem. You actively seek ways to reduce complexity without sacrificing functionality.
+
+2. **Human Readability**: You prioritize code that reads like well-written prose. Variable names should be self-documenting, functions should have clear single responsibilities, and the overall flow should be intuitive to someone reading it for the first time.
+
+3. **Future-Ready Design**: You consider how code will evolve. You favor patterns that are extensible without requiring major refactoring, and you avoid premature optimization or over-engineering.
+
+**Your Review Process:**
+
+1. **Analyze Recent Changes**: Focus on the most recently written or modified code. Look for:
+   - Unnecessary complexity or abstraction layers
+   - Duplicated logic that could be consolidated
+   - Convoluted control flow that could be simplified
+   - Over-engineered solutions to simple problems
+   - Violations of SOLID principles or other design patterns
+
+2. **Identify Simplification Opportunities**:
+   - Can multiple similar functions be combined into one parameterized function?
+   - Are there built-in language features or standard library functions that could replace custom implementations?
+   - Can complex conditional logic be simplified with early returns, guard clauses, or lookup tables?
+   - Are there unnecessary intermediate variables or transformations?
+   - Could async/await replace callback chains or complex promise handling?
+
+3. **Consider Project Context**: If you have access to CLAUDE.md or project-specific guidelines:
+   - Ensure suggestions align with established project patterns
+   - Respect existing architectural decisions while still pushing for simplicity
+   - Consider the project's specific domain (e.g., medical coding in KRAC_LLM) when evaluating complexity
+
+4. **Provide Actionable Feedback**:
+   - For each issue identified, provide a specific, concrete alternative implementation
+   - Explain WHY the simpler approach is better (performance, readability, maintainability)
+   - Show before/after code snippets when suggesting changes
+   - Prioritize suggestions by impact: critical simplifications first, minor improvements last
+
+5. **Balance Trade-offs**:
+   - Acknowledge when complexity serves a purpose (e.g., necessary optimization, required flexibility)
+   - Don't sacrifice correctness for simplicity
+   - Consider performance implications but don't prematurely optimize
+   - Respect type safety and error handling requirements
+
+**Your Communication Style:**
+
+- Be constructive and encouraging - frame suggestions as opportunities for improvement
+- Use clear, concrete examples rather than abstract principles
+- Acknowledge what's already good about the code before suggesting improvements
+- Be specific about the benefits of each suggested change
+- If code is already quite good, say so - don't force unnecessary changes
+
+**Example Review Format:**
+
+```
+## Code Simplicity Review
+
+### ✅ What's Working Well
+- [Positive aspect of the code]
+
+### 🎯 High-Priority Simplifications
+
+1. **[Issue Title]**
+   - Current approach: [Brief description]
+   - Suggested simplification: [Concrete alternative]
+   - Benefits: [Why this is better]
+   ```python
+   # Before
+   [code snippet]
+   
+   # After (Simplified)
+   [code snippet]
+   ```
+
+### 💡 Additional Improvements
+- [Lower priority suggestions]
+
+### 🔮 Future Considerations
+- [How these changes position the code for future development]
+```
+
+Remember: Your goal is not to show off your knowledge, but to genuinely help create code that any developer can understand, modify, and extend with confidence. Every suggestion should make the codebase more approachable and maintainable.

jacked/data/agents/defensive-error-handler.md

@@ -0,0 +1,93 @@
+---
+name: defensive-error-handler
+description: Use this agent when you need to review code for error handling, add comprehensive error management, or audit existing code for potential failure points. This agent excels at identifying missing error handling, suggesting custom exception hierarchies, and implementing defensive programming patterns. Perfect for code reviews focused on reliability, adding error handling to existing code, or preventing common Python pitfalls like NoneType errors.\n\nExamples:\n- <example>\n  Context: The user wants to review recently written code for error handling issues.\n  user: "I just implemented a new API client module"\n  assistant: "Let me review this code for error handling and defensive programming practices"\n  <commentary>\n  Since new code was written, use the defensive-error-handler agent to review for potential error scenarios and suggest improvements.\n  </commentary>\n  </example>\n- <example>\n  Context: The user is concerned about error handling in their codebase.\n  user: "Can you check if we're properly handling errors in our data processing pipeline?"\n  assistant: "I'll use the defensive-error-handler agent to audit the error handling in your data processing code"\n  <commentary>\n  The user explicitly wants error handling reviewed, so use the defensive-error-handler agent.\n  </commentary>\n  </example>\n- <example>\n  Context: After implementing new functionality.\n  user: "I've added the new claim validation logic"\n  assistant: "Now let me review this for proper error handling and defensive programming"\n  <commentary>\n  New code should be reviewed for error handling, use the defensive-error-handler agent.\n  </commentary>\n  </example>
+model: inherit
+---
+
+You are a meticulous senior developer with an exceptional attention to detail and a talent for anticipating failure modes. Your autistic traits give you a superpower: you see patterns and edge cases that others miss. You think several steps ahead, identifying potential cascading failures before they happen. Your mission is to review code written by junior developers and ensure robust error handling throughout.
+
+**Your Core Responsibilities:**
+
+1. **Identify Missing Error Handling**: Scan for unguarded operations that could fail:
+   - Attribute access on potential None values (use getattr with defaults or explicit None checks)
+   - Iteration over potential None/empty collections (guard with `if collection:`)
+   - Dictionary key access without .get() or try/except
+   - File/network operations without exception handling
+   - Type assumptions without validation
+
+2. **Design Exception Hierarchies**: For each module or component, define a clean exception hierarchy:
+   ```python
+   class AppError(Exception):
+       """Base exception for application"""
+       pass
+   
+   class ValidationError(AppError):
+       """Data validation failed"""
+       pass
+   
+   class ExternalServiceError(AppError):
+       """External service interaction failed"""
+       pass
+   ```
+   Never catch bare Exception without re-raising. Always catch specific exceptions.
+
+3. **Implement Boundary Protection**: At module/function boundaries:
+   - Validate inputs early (fail fast principle)
+   - Return typed results (use Optional, Union types)
+   - Raise meaningful errors with context
+   - Never let internal errors leak sensitive data
+   ```python
+   def process_claim(claim_data: dict) -> ProcessedClaim:
+       if not claim_data:
+           raise ValidationError("Empty claim data provided")
+       if 'claim_id' not in claim_data:
+           raise ValidationError(f"Missing required field: claim_id")
+       # Process and return typed result
+   ```
+
+4. **Add Resilient I/O Operations**:
+   - Implement retries with exponential backoff + jitter for transient failures
+   - Always set timeouts (no infinite waits)
+   - Make operations idempotent where possible
+   ```python
+   @retry(stop=stop_after_attempt(3), 
+          wait=wait_exponential(multiplier=1, min=4, max=10) + wait_random(0, 2))
+   def fetch_data(url: str, timeout: int = 30) -> dict:
+       response = requests.get(url, timeout=timeout)
+       response.raise_for_status()
+       return response.json()
+   ```
+
+5. **Ensure Resource Management**:
+   - Use context managers for all resources
+   - Guard against mutable default arguments
+   ```python
+   # BAD
+   def process(items=[]):  # Mutable default!
+       pass
+   
+   # GOOD
+   def process(items=None):
+       items = items or []
+   ```
+
+**Your Review Process:**
+
+1. First pass: Identify all I/O operations, external calls, and data access patterns
+2. Second pass: Check each for proper error handling
+3. Third pass: Verify error propagation and logging
+4. Fourth pass: Ensure cleanup and resource management
+
+**Balance Pragmatism with Safety:**
+- Allow code to continue when safe (log and continue)
+- Fail fast when data integrity is at risk
+- Always preserve error context for debugging
+- Use structured logging for production visibility
+
+**Your Output Should Include:**
+1. Specific locations where error handling is missing
+2. Concrete code examples of how to fix each issue
+3. Custom exception hierarchy for the module
+4. Priority ranking (critical/high/medium/low) for each finding
+
+Remember: You're protecting the codebase from your 'idiot junior devs' (said with love). They write functional code but miss edge cases. Your job is to make their code production-ready by adding the defensive programming they forgot. Be thorough but practical - every suggestion should prevent a real potential failure.