contextly 0.1.0__tar.gz → 0.1.4__tar.gz

{contextly-0.1.0 → contextly-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: contextly
-Version: 0.1.0
+Version: 0.1.4
 Summary: AI Context Engine for Developers
 Project-URL: Homepage, https://github.com/contextly/contextly
 Project-URL: Repository, https://github.com/contextly/contextly

{contextly-0.1.0 → contextly-0.1.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "contextly"
-version = "0.1.0"
+version = "0.1.4"
 authors = [
     { name = "Contextly Team", email = "team@contextly.dev" },
 ]

contextly-0.1.4/src/contextly/app.py

@@ -0,0 +1,111 @@
+"""
+Core business logic for Contextly commands.
+"""
+
+from pathlib import Path
+from typing import Dict, Any, Optional
+
+from .core.analyzer import CodeAnalyzer
+from .core.embeddings import EmbeddingEngine
+from .core.sync import RepoSync
+from .llm import LLMManager
+
+class Contextly:
+    """Main class coordinating Contextly's functionality."""
+    
+    def __init__(self, repo_path: Optional[Path] = None, model: Optional[str] = None):
+        self.repo_path = repo_path or Path.cwd()
+        self.llm_manager = LLMManager(model)
+        self.analyzer = CodeAnalyzer(self.repo_path)
+        self.embedding_engine = EmbeddingEngine(self.repo_path)
+        self.repo_sync = RepoSync(self.repo_path)
+        
+    def ask(self, question: str) -> Dict[str, Any]:
+        """Answer questions about the codebase."""
+        try:
+            # Search for relevant code
+            search_results = self.embedding_engine.search(question)
+            
+            # Build context from search results
+            context = []
+            for result in search_results['results']:
+                context.append(f"From {result['file']}:\n{result['content']}\n")
+            
+            if not context:
+                return {
+                    'answer': 'No relevant code found to answer the question.',
+                    'context': search_results
+                }
+                
+            # Generate answer using LLM
+            context_str = '\n'.join(context)
+            context_dict = {
+                'question': question,
+                'code_snippets': context,
+                'files': [r['file'] for r in search_results['results']]
+            }
+            
+            answer = self.llm_manager.explain_code(context_str, context_dict)
+            
+            return {
+                'answer': answer,
+                'context': search_results
+            }
+        except Exception as e:
+            return {
+                'error': f'Failed to process question: {str(e)}',
+                'context': None
+            }
+        
+    def explain(self, location: str) -> str:
+        """Explain code at specific location."""
+        try:
+            if ':' not in location:
+                return "Invalid location format. Use 'file:line_number'"
+            file_path, line_number = location.split(':')
+            return self.analyzer.explain_code(file_path, int(line_number))
+        except ValueError:
+            return f"Invalid line number in location: {location}"
+        except Exception as e:
+            return f"Error explaining code: {str(e)}"
+        
+    def search(self, term: str) -> Dict[str, Any]:
+        """Semantic search across codebase."""
+        try:
+            results = self.embedding_engine.search(term)
+            return {
+                'query': results['query'],
+                'results': results['results']
+            }
+        except Exception as e:
+            return {
+                'query': term,
+                'error': str(e),
+                'results': []
+            }
+        
+    def diff(self, path1: Path, path2: Path) -> Dict[str, Any]:
+        """Compare configuration files."""
+        return self.analyzer.compare_configs(path1, path2)
+        
+    def sync(self) -> None:
+        """Build or rebuild the embedding index."""
+        # Scan repository
+        files = list(self.repo_sync.scan_files())
+        
+        # Build index
+        index = self.repo_sync.index_repository()
+        
+        # Convert index to list of documents
+        docs = []
+        for file_path, file_data in index.items():
+            docs.extend(file_data.get('chunks', []))
+            
+        # Build or update the embedding index with the documents
+        try:
+            if docs:
+                self.embedding_engine.embed_documents(docs)
+            else:
+                print("No documents found to index")
+        except Exception as e:
+            raise RuntimeError(f"Failed to update search index: {str(e)}")

{contextly-0.1.0 → contextly-0.1.4}/src/contextly/core/analyzer.py

@@ -5,7 +5,9 @@ Core functionality for code parsing and analysis.
 import difflib
 from pathlib import Path
 from typing import List, Dict, Any, Optional
+from typing import Type
 from ..llm import LLMManager
+from ..parsers.base import BaseParser
 from ..parsers.python import PythonParser
 from ..parsers.javascript import JavaScriptParser
 from ..parsers.config import ConfigParser
@@ -66,8 +68,13 @@ class CodeAnalyzer:
             return f"No code found at line {line_number}"
             
         # Get explanation from LLM
-        prompt = f"Explain this {result['file_type']} code snippet:\n\n{target_chunk['content']}"
-        explanation = self.llm.generate(prompt)
+        code = target_chunk['content']
+        context = {
+            'file_type': result['file_type'],
+            'file_path': file_path,
+            'line_number': line_number
+        }
+        explanation = self.llm.explain_code(code, context)
         
         return explanation
         

contextly-0.1.4/src/contextly/core/embeddings.py

@@ -0,0 +1,129 @@
+"""
+Vector embedding and similarity search functionality.
+"""
+
+from pathlib import Path
+import os
+from typing import List, Dict, Any, Optional
+import chromadb
+from chromadb.config import Settings
+from sentence_transformers import SentenceTransformer
+
+class EmbeddingEngine:
+    """Handles document embedding and similarity search."""
+    
+    def __init__(self, repo_path: Path):
+        """Initialize the embedding engine with the given repository path."""
+        self.repo_path = repo_path
+        self.model: Optional[SentenceTransformer] = None
+        self.db = None
+        self.collection = None
+        self.data_dir = self.repo_path / '.contextly' / 'embeddings'
+        self.collection_name = "code_embeddings"
+        self.data_dir.mkdir(parents=True, exist_ok=True)
+        
+    def _initialize(self) -> None:
+        """Initialize the model and database if not already initialized."""
+        if self.model is None:
+            try:
+                self.model = SentenceTransformer('all-MiniLM-L6-v2')
+            except Exception as e:
+                raise RuntimeError(f"Failed to initialize embedding model: {str(e)}")
+                
+        if self.db is None:
+            try:
+                self.db = chromadb.PersistentClient(path=str(self.data_dir))
+                self.collection = self.db.get_or_create_collection(
+                    name=self.collection_name,
+                    metadata={"repo_path": str(self.repo_path)}
+                )
+            except Exception as e:
+                raise RuntimeError(f"Failed to initialize ChromaDB: {str(e)}")
+                
+    def _ensure_initialized(self) -> None:
+        """Ensure both model and database are initialized."""
+        if self.model is None or self.db is None or self.collection is None:
+            self._initialize()
+        """Initialize the embedding model and vector store if not already initialized."""
+        self._ensure_initialized()
+        
+    def embed_documents(self, documents: List[Dict[str, Any]]):
+        """Convert documents into vector embeddings and store them."""
+        if not documents:
+            return
+            
+        # Ensure initialization
+        self._ensure_initialized()
+        
+        # Prepare documents for ChromaDB
+        texts = []
+        metadatas = []
+        ids = []
+        
+        for idx, doc in enumerate(documents):
+            # Create a meaningful document summary
+            doc_text = f"{doc.get('type', 'unknown')} - {doc.get('name', '')}:\n{doc.get('content', '')}"
+            texts.append(doc_text)
+            
+            # Store metadata
+            metadatas.append({
+                "file_path": str(doc.get("file_path", "")),
+                "type": doc.get("type", "unknown"),
+                "name": doc.get("name", ""),
+                "start_line": doc.get("start_line", 0),
+                "end_line": doc.get("end_line", 0),
+            })
+            
+            # Generate unique ID
+            doc_id = f"doc_{idx}_{hash(doc_text) & 0xFFFFFFFF}"
+            ids.append(doc_id)
+            
+        # Ensure collection is initialized
+        if self.collection is None:
+            raise RuntimeError("Collection is not initialized.")
+        # Add documents to the collection
+        self.collection.add(
+            documents=texts,
+            metadatas=metadatas,
+            ids=ids
+        )
+        
+    def search(self, query: str, top_k: int = 5) -> Dict[str, Any]:
+        """Search for most similar documents to query."""
+        self._ensure_initialized()
+        
+        # Ensure collection is initialized
+        if self.collection is None:
+            raise RuntimeError("Collection is not initialized.")
+        
+        # Query the collection
+        results = self.collection.query(
+            query_texts=[query],
+            n_results=top_k
+        )
+        
+        # Format results
+        hits = []
+        documents = results.get('documents')
+        metadatas = results.get('metadatas')
+        distances = results.get('distances')
+        ids = results.get('ids')
+
+        if documents is not None and metadatas is not None and ids is not None:
+            for i in range(len(ids[0])):
+                hits.append({
+                    'content': documents[0][i] if documents[0] is not None else None,
+                    'metadata': metadatas[0][i] if metadatas[0] is not None else None,
+                    'score': distances[0][i] if distances and distances[0] is not None else None,
+                    'file': metadatas[0][i]['file_path'] if metadatas[0] is not None else None
+                })
+
+        return {
+            'query': query,
+            'results': hits
+        }
+        
+    def clear(self):
+        """Clear all embeddings from storage."""
+        if self.collection:
+            self.collection.delete()

contextly-0.1.4/src/contextly/llm/__init__.py

@@ -0,0 +1,13 @@
+"""LLM package for Contextly."""
+
+from .manager import LLMManager
+from .base import LLMProvider
+from .models import ModelManager, ModelRegistry, ModelProvider
+
+__all__ = [
+    'LLMManager',
+    'LLMProvider',
+    'ModelManager',
+    'ModelRegistry',
+    'ModelProvider'
+]

{contextly-0.1.0 → contextly-0.1.4}/src/contextly/llm/models.py

@@ -2,7 +2,7 @@
 Model management system for various LLM providers.
 """
 
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from enum import Enum
 from typing import Dict, Any, Optional, List
 import requests
@@ -25,7 +25,7 @@ class ModelInfo:
     description: str
     context_length: int
     quantization: Optional[str] = None
-    metadata: Dict[str, Any] = None
+    metadata: Dict[str, Any] = field(default_factory=dict)
 
 class ModelRegistry:
     """Registry of available models and their capabilities."""
@@ -37,19 +37,28 @@ class ModelRegistry:
         
     def _load_models(self) -> None:
         """Load model registry from config file."""
-        if self.config_path.exists():
-            with open(self.config_path, 'r') as f:
-                data = json.load(f)
-                for model_data in data.get('models', []):
-                    info = ModelInfo(
-                        name=model_data['name'],
-                        provider=ModelProvider(model_data['provider']),
-                        description=model_data.get('description', ''),
-                        context_length=model_data.get('context_length', 4096),
-                        quantization=model_data.get('quantization'),
-                        metadata=model_data.get('metadata', {})
-                    )
-                    self.models[model_data['name']] = info
+        try:
+            if self.config_path.exists():
+                with open(self.config_path, 'r') as f:
+                    try:
+                        data = json.load(f)
+                        for model_data in data.get('models', []):
+                            try:
+                                info = ModelInfo(
+                                    name=model_data['name'],
+                                    provider=ModelProvider(model_data['provider']),
+                                    description=model_data.get('description', ''),
+                                    context_length=model_data.get('context_length', 4096),
+                                    quantization=model_data.get('quantization'),
+                                    metadata=model_data.get('metadata', {})
+                                )
+                                self.models[model_data['name']] = info
+                            except (KeyError, ValueError) as e:
+                                print(f"Warning: Skipping invalid model data: {e}")
+                    except Exception as e:
+                        print(f"Error loading models from config: {e}")
+        except Exception as e:
+            print(f"Error accessing config file: {e}")
                     
     def _save_models(self) -> None:
         """Save model registry to config file."""

{contextly-0.1.0 → contextly-0.1.4}/src/contextly/llm/openai.py

@@ -10,7 +10,7 @@ from .base import LLMProvider
 class OpenAIProvider(LLMProvider):
     """LLM provider using OpenAI API."""
     
-    DEFAULT_MODEL = "gpt-4-mini"
+    DEFAULT_MODEL = "gpt-3.5-turbo"
     
     def __init__(self, model: str = DEFAULT_MODEL, api_key: Optional[str] = None):
         self.model = model
@@ -27,6 +27,8 @@ class OpenAIProvider(LLMProvider):
             raise RuntimeError("OpenAI API is not configured")
             
         try:
+            if self.client is None:
+                raise RuntimeError("OpenAI client is not initialized. Please provide a valid API key.")
             response = self.client.chat.completions.create(
                 model=self.model,
                 messages=[{"role": "user", "content": prompt}],

{contextly-0.1.0 → contextly-0.1.4}/tests/test_core.py

@@ -117,7 +117,6 @@ def test_embedding_engine(sample_repo_path):
     engine = EmbeddingEngine(sample_repo_path)
     
     # Test initialization
-    engine.initialize()
     assert engine.model is not None
     assert engine.db is not None
     

contextly-0.1.0/src/contextly/app.py

@@ -1,85 +0,0 @@
-"""
-Core business logic for Contextly commands.
-"""
-
-from pathlib import Path
-from typing import Dict, Any, Optional
-
-from .core.analyzer import CodeAnalyzer
-from .core.embeddings import EmbeddingEngine
-from .core.sync import RepoSync
-from .llm.manager import LLMManager
-
-class Contextly:
-    """Main class coordinating Contextly's functionality."""
-    
-    def __init__(self, repo_path: Optional[Path] = None, model: Optional[str] = None):
-        self.repo_path = repo_path or Path.cwd()
-        self.llm_manager = LLMManager(model)
-        self.analyzer = CodeAnalyzer(self.repo_path)
-        self.embedding_engine = EmbeddingEngine(self.repo_path)
-        self.repo_sync = RepoSync(self.repo_path)
-        
-    def ask(self, question: str) -> Dict[str, Any]:
-        """Answer questions about the codebase."""
-        # Initialize if needed
-        if not hasattr(self, '_initialized'):
-            self.embedding_engine.initialize()
-            self._initialized = True
-            
-        # Search for relevant code
-        search_results = self.embedding_engine.search(question)
-        
-        # Build context from search results
-        context = []
-        for result in search_results['results']:
-            context.append(f"From {result['file']}:\n{result['content']}\n")
-            
-        # Generate answer using LLM
-        prompt = f"Question: {question}\n\nContext from codebase:\n{''.join(context)}\n\nAnswer:"
-        answer = self.analyzer.llm.generate(prompt)
-        
-        return {
-            'answer': answer,
-            'context': search_results
-        }
-        
-    def explain(self, location: str) -> str:
-        """Explain code at specific location."""
-        file_path, line_number = location.split(':')
-        return self.analyzer.explain_code(file_path, int(line_number))
-        
-    def search(self, term: str) -> Dict[str, Any]:
-        """Semantic search across codebase."""
-        if not hasattr(self, '_initialized'):
-            self.embedding_engine.initialize()
-            self._initialized = True
-            
-        results = self.embedding_engine.search(term)
-        return {
-            'query': results['query'],
-            'results': results['results']
-        }
-        
-    def diff(self, path1: Path, path2: Path) -> Dict[str, Any]:
-        """Compare configuration files."""
-        return self.analyzer.compare_configs(path1, path2)
-        
-    def sync(self) -> None:
-        """Build or rebuild the embedding index."""
-        # Scan repository
-        files = list(self.repo_sync.scan_files())
-        
-        # Build index
-        index = self.repo_sync.index_repository()
-        
-        # Initialize embedding engine
-        self.embedding_engine.initialize()
-        
-        # Convert index to list of documents
-        docs = []
-        for file_path, file_data in index.items():
-            docs.extend(file_data.get('chunks', []))
-            
-        # Embed documents
-        self.embedding_engine.embed_documents(docs)

contextly-0.1.0/src/contextly/core/embeddings.py

@@ -1,109 +0,0 @@
-"""
-Vector embedding and similarity search functionality.
-"""
-
-from pathlib import Path
-import os
-from typing import List, Dict, Any, Optional
-import chromadb
-from chromadb.config import Settings
-from sentence_transformers import SentenceTransformer
-
-class EmbeddingEngine:
-    """Handles document embedding and similarity search."""
-    
-    def __init__(self, repo_path: Path):
-        self.repo_path = repo_path
-        self.model = None  # Lazy load the model
-        self.db = None  # Initialize ChromaDB client
-        self.collection = None
-        
-    def initialize(self):
-        """Initialize the embedding model and vector store."""
-        if self.model is None:
-            self.model = SentenceTransformer('all-MiniLM-L6-v2')
-            
-        if self.db is None:
-            # Create .contextly directory if it doesn't exist
-            db_path = self.repo_path / '.contextly'
-            os.makedirs(db_path, exist_ok=True)
-            
-            # Initialize ChromaDB with persistent storage
-            self.db = chromadb.Client(Settings(
-                persist_directory=str(db_path),
-                anonymized_telemetry=False
-            ))
-            
-            # Get or create collection for this repo
-            self.collection = self.db.get_or_create_collection(
-                name="contextly_docs",
-                metadata={"repo_path": str(self.repo_path)}
-            )
-        
-    def embed_documents(self, documents: List[Dict[str, Any]]):
-        """Convert documents into vector embeddings and store them."""
-        if not documents:
-            return
-            
-        # Ensure initialization
-        self.initialize()
-        
-        # Prepare documents for ChromaDB
-        texts = []
-        metadatas = []
-        ids = []
-        
-        for idx, doc in enumerate(documents):
-            # Create a meaningful document summary
-            doc_text = f"{doc.get('type', 'unknown')} - {doc.get('name', '')}:\n{doc.get('content', '')}"
-            texts.append(doc_text)
-            
-            # Store metadata
-            metadatas.append({
-                "file_path": str(doc.get("file_path", "")),
-                "type": doc.get("type", "unknown"),
-                "name": doc.get("name", ""),
-                "start_line": doc.get("start_line", 0),
-                "end_line": doc.get("end_line", 0),
-            })
-            
-            # Generate unique ID
-            doc_id = f"doc_{idx}_{hash(doc_text) & 0xFFFFFFFF}"
-            ids.append(doc_id)
-            
-        # Add documents to the collection
-        self.collection.add(
-            documents=texts,
-            metadatas=metadatas,
-            ids=ids
-        )
-        
-    def search(self, query: str, top_k: int = 5) -> Dict[str, Any]:
-        """Search for most similar documents to query."""
-        self.initialize()
-        
-        # Query the collection
-        results = self.collection.query(
-            query_texts=[query],
-            n_results=top_k
-        )
-        
-        # Format results
-        hits = []
-        for i in range(len(results['ids'][0])):
-            hits.append({
-                'content': results['documents'][0][i],
-                'metadata': results['metadatas'][0][i],
-                'score': results['distances'][0][i] if 'distances' in results else None,
-                'file': results['metadatas'][0][i]['file_path']
-            })
-            
-        return {
-            'query': query,
-            'results': hits
-        }
-        
-    def clear(self):
-        """Clear all embeddings from storage."""
-        if self.collection:
-            self.collection.delete()