claude-self-reflect 2.3.6 → 2.3.7

package/scripts/import-current-conversation.py

@@ -1,39 +0,0 @@
-#!/usr/bin/env python3
-"""Quick import of current conversation using Voyage AI"""
-
-import os
-import sys
-sys.path.append(os.path.dirname(os.path.abspath(__file__)))
-
-import importlib.util
-spec = importlib.util.spec_from_file_location("voyage_importer", 
-    os.path.join(os.path.dirname(__file__), "import-conversations-voyage.py"))
-voyage_module = importlib.util.module_from_spec(spec)
-spec.loader.exec_module(voyage_module)
-VoyageConversationImporter = voyage_module.VoyageConversationImporter
-
-def main():
-    # Import just the current conversation
-    importer = VoyageConversationImporter()
-    
-    # Example: Update these to your project path and file
-    project_path = os.path.expanduser("~/.claude/projects/your-project-name")
-    target_file = "your-conversation-id.jsonl"
-    
-    print(f"Importing current conversation: {target_file}")
-    
-    # Process just this file
-    file_path = os.path.join(project_path, target_file)
-    if os.path.exists(file_path):
-        chunks = importer.process_jsonl_file(file_path)
-        if chunks:
-            collection_name = importer.get_collection_name(os.path.basename(project_path))
-            importer.import_chunks(chunks, collection_name)
-            print(f"✅ Imported {len(chunks)} chunks from current conversation")
-        else:
-            print("❌ No chunks found in current conversation")
-    else:
-        print(f"❌ File not found: {file_path}")
-
-if __name__ == "__main__":
-    main()

package/scripts/import-live-conversation.py

@@ -1,154 +0,0 @@
-#!/usr/bin/env python3
-"""Import the currently active conversation file."""
-
-import os
-import sys
-import json
-import hashlib
-from datetime import datetime, timedelta
-from qdrant_client import QdrantClient
-from qdrant_client.models import PointStruct, VectorParams, Distance
-import backoff
-import requests
-
-# Configuration
-QDRANT_URL = "http://localhost:6333"
-VOYAGE_API_KEY = os.getenv("VOYAGE_KEY")
-VOYAGE_API_URL = "https://api.voyageai.com/v1/embeddings"
-
-@backoff.on_exception(backoff.expo, Exception, max_tries=3)
-def generate_embedding(text):
-    """Generate embedding using Voyage AI."""
-    headers = {
-        "Authorization": f"Bearer {VOYAGE_API_KEY}",
-        "Content-Type": "application/json"
-    }
-    
-    response = requests.post(
-        VOYAGE_API_URL,
-        headers=headers,
-        json={
-            "input": [text],
-            "model": "voyage-3-large"
-        }
-    )
-    
-    if response.status_code != 200:
-        raise Exception(f"Voyage API error: {response.status_code} - {response.text}")
-        
-    return response.json()["data"][0]["embedding"]
-
-def import_conversation(file_path):
-    """Import a single conversation file."""
-    client = QdrantClient(url=QDRANT_URL)
-    
-    # Determine collection name
-    # Example: Update to your project path
-    project_path = os.path.expanduser("~/your-project-path")
-    project_hash = hashlib.md5(project_path.encode()).hexdigest()[:8]
-    collection_name = f"conv_{project_hash}_voyage"
-    
-    print(f"Importing to collection: {collection_name}")
-    
-    # Ensure collection exists
-    collections = [c.name for c in client.get_collections().collections]
-    if collection_name not in collections:
-        client.create_collection(
-            collection_name=collection_name,
-            vectors_config=VectorParams(size=1024, distance=Distance.COSINE)
-        )
-    
-    # Read recent messages (last 2 hours)
-    from datetime import timezone
-    cutoff = datetime.now(timezone.utc) - timedelta(hours=2)
-    points_to_import = []
-    
-    with open(file_path, 'r') as f:
-        for line in f:
-            try:
-                entry = json.loads(line)
-                timestamp_str = entry.get('timestamp', '')
-                
-                # Parse timestamp
-                if timestamp_str:
-                    # Convert ISO format to datetime
-                    timestamp = datetime.fromisoformat(timestamp_str.replace('Z', '+00:00'))
-                    
-                    # Only import recent entries
-                    if timestamp > cutoff:
-                        # Extract message content
-                        message = entry.get('message', {})
-                        content = message.get('content', [])
-                        
-                        # Extract text from content
-                        text_parts = []
-                        for item in content:
-                            if isinstance(item, dict) and item.get('type') == 'text':
-                                text_parts.append(item.get('text', ''))
-                        
-                        if text_parts:
-                            text = ' '.join(text_parts)
-                            
-                            # Create unique ID
-                            point_id = hashlib.md5(f"{entry.get('uuid', '')}_{timestamp_str}".encode()).hexdigest()
-                            
-                            # Generate embedding
-                            print(f"Generating embedding for entry from {timestamp_str[:19]}")
-                            try:
-                                embedding = generate_embedding(text[:8000])  # Limit text length
-                                
-                                points_to_import.append(
-                                    PointStruct(
-                                        id=point_id,
-                                        vector=embedding,
-                                        payload={
-                                            "text": text[:2000],
-                                            "timestamp": timestamp.timestamp(),
-                                            "role": message.get('role', 'unknown'),
-                                            "conversation_id": entry.get('sessionId', ''),
-                                            "project": project_path
-                                        }
-                                    )
-                                )
-                                
-                                # Import in batches
-                                if len(points_to_import) >= 10:
-                                    client.upsert(
-                                        collection_name=collection_name,
-                                        points=points_to_import
-                                    )
-                                    print(f"Imported batch of {len(points_to_import)} points")
-                                    points_to_import = []
-                                    
-                            except Exception as e:
-                                print(f"Error generating embedding: {e}")
-                                
-            except json.JSONDecodeError:
-                continue
-                
-    # Import remaining points
-    if points_to_import:
-        client.upsert(
-            collection_name=collection_name,
-            points=points_to_import
-        )
-        print(f"Imported final batch of {len(points_to_import)} points")
-    
-    # Check collection status
-    info = client.get_collection(collection_name)
-    print(f"\nCollection {collection_name} now has {info.points_count} points")
-
-def main():
-    # Example: Update to your conversation file path
-    file_path = os.path.expanduser("~/.claude/projects/your-project/your-conversation-id.jsonl")
-    
-    if not os.path.exists(file_path):
-        print(f"File not found: {file_path}")
-        return
-        
-    print(f"Importing live conversation from: {file_path}")
-    import_conversation(file_path)
-    print("\nImport complete!")
-
-if __name__ == "__main__":
-    main()