contextly 0.1.0__tar.gz → 0.1.7__tar.gz

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

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: contextly
-Version: 0.1.0
+Version: 0.1.7
 Summary: AI Context Engine for Developers
-Project-URL: Homepage, https://github.com/contextly/contextly
-Project-URL: Repository, https://github.com/contextly/contextly
-Project-URL: Documentation, https://github.com/contextly/contextly#readme
-Project-URL: Bug Tracker, https://github.com/contextly/contextly/issues
-Author-email: Contextly Team <team@contextly.dev>
+Project-URL: Homepage, https://github.com/desenyon/contextly
+Project-URL: Repository, https://github.com/desenyon/contextly
+Project-URL: Documentation, https://github.com/desenyon/contextly#readme
+Project-URL: Bug Tracker, https://github.com/desenyon/contextly/issues
+Author-email: Contextly Team <desenyon@gmail.com>
 License-Expression: MIT
 License-File: LICENSE
 Keywords: ai,analysis,code,context,development,documentation,llm
@@ -41,16 +41,11 @@ Requires-Dist: toml>=0.10.2
 Requires-Dist: tqdm>=4.66.1
 Requires-Dist: transformers>=4.35.0
 Requires-Dist: typer>=0.9.0
-Provides-Extra: dev
-Requires-Dist: black>=23.0.0; extra == 'dev'
-Requires-Dist: isort>=5.12.0; extra == 'dev'
-Requires-Dist: mypy>=1.5.0; extra == 'dev'
-Requires-Dist: pre-commit>=3.3.0; extra == 'dev'
-Requires-Dist: ruff>=0.1.0; extra == 'dev'
 Provides-Extra: test
 Requires-Dist: black>=23.0.0; extra == 'test'
 Requires-Dist: isort>=5.12.0; extra == 'test'
 Requires-Dist: mypy>=1.5.0; extra == 'test'
+Requires-Dist: pre-commit>=3.3.0; extra == 'test'
 Requires-Dist: pytest-asyncio>=0.21.0; extra == 'test'
 Requires-Dist: pytest-cov>=4.0.0; extra == 'test'
 Requires-Dist: pytest>=7.0.0; extra == 'test'

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

@@ -4,9 +4,9 @@ build-backend = "hatchling.build"
 
 [project]
 name = "contextly"
-version = "0.1.0"
+version = "0.1.7"
 authors = [
-    { name = "Contextly Team", email = "team@contextly.dev" },
+    { name = "Contextly Team", email = "desenyon@gmail.com" },
 ]
 description = "AI Context Engine for Developers"
 readme = "README.md"
@@ -58,29 +58,22 @@ test = [
     "isort>=5.12.0",
     "mypy>=1.5.0",
     "ruff>=0.1.0",
-]
-
-dev = [
-    "pre-commit>=3.3.0",
-    "black>=23.0.0",
-    "isort>=5.12.0",
-    "mypy>=1.5.0",
-    "ruff>=0.1.0",
+    "pre-commit>=3.3.0"
 ]
 
 [project.scripts]
 contextly = "contextly.cli:app"
 
 [project.urls]
-Homepage = "https://github.com/contextly/contextly"
-Repository = "https://github.com/contextly/contextly"
-Documentation = "https://github.com/contextly/contextly#readme"
-"Bug Tracker" = "https://github.com/contextly/contextly/issues"
+Homepage = "https://github.com/desenyon/contextly"
+Repository = "https://github.com/desenyon/contextly"
+Documentation = "https://github.com/desenyon/contextly#readme"
+"Bug Tracker" = "https://github.com/desenyon/contextly/issues"
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 python_files = ["test_*.py"]
-addopts = "--cov=contextly --cov-report=term-missing"
+addopts = "-v"
 
 [tool.black]
 line-length = 100

contextly-0.1.7/requirements.txt

@@ -0,0 +1,19 @@
+# Core dependencies
+pyyaml>=6.0.1
+python-dotenv>=1.0.0
+
+# LLM and embeddings
+openai>=1.0.0
+langchain>=0.0.300
+transformers>=4.34.0
+sentence-transformers>=2.2.2
+
+# Testing
+pytest>=7.4.2
+pytest-cov>=4.1.0
+
+# Development
+black>=23.9.1
+isort>=5.12.0
+flake8>=6.1.0
+mypy>=1.5.1

contextly-0.1.7/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.7}/src/contextly/cli.py

@@ -2,6 +2,7 @@
 Main CLI interface for Contextly
 """
 
+import os
 import typer
 from rich import print
 from rich.console import Console
@@ -36,17 +37,28 @@ def ask(
     print("🔍 Searching for answer...")
     result = get_contextly().ask(question)
     
+    # Print answer or error in a panel
+    if 'error' in result:
+        console.print(Panel(
+            result['error'],
+            title="❌ Error",
+            border_style="red"
+        ))
+        return
+        
     # Print answer in a panel
-    console.print(Panel(
-        Markdown(result['answer']),
-        title="💡 Answer",
-        border_style="blue"
-    ))
-    
-    # Print relevant code snippets
-    if result.get('context', {}).get('results'):
-        console.print("\n📚 Relevant code:")
-        for snippet in result['context']['results']:
+    if 'answer' in result:
+        console.print(Panel(
+            Markdown(result['answer']),
+            title="💡 Answer",
+            border_style="blue"
+        ))
+        
+        # Print relevant code snippets
+        if result.get('context', {}).get('results'):
+            console.print("\n📚 Relevant code:")
+            for snippet in result['context']['results']:
+                console.print("")  # Add a blank line for readability
             console.print(Panel(
                 Syntax(
                     snippet['content'],
@@ -133,9 +145,33 @@ def sync(
     ),
 ) -> None:
     """Build or rebuild the local embedding index."""
-    print("🔄 Syncing repository...")
-    get_contextly(path).sync()
-    print("✨ Repository indexed successfully!")
+    # Create fancy header
+    console.print(Panel(
+        "[bold blue]Contextly Repository Sync[/]",
+        subtitle="Building semantic search index",
+        style="blue"
+    ))
+
+    contextly = get_contextly(path)
+    
+    # Check model status first
+    model_name = os.getenv('CONTEXTLY_MODEL', 'codellama')
+    status = contextly.llm_manager.model_manager.registry.check_model_status(model_name)
+    
+    if status['installed'] and status['ready']:
+        console.print(f"[green]✓[/] Using existing {model_name} model")
+    else:
+        console.print(f"[yellow]![/] {status['message']}")
+        console.print(f"[yellow]⚡[/] Downloading {model_name}...")
+    
+    with console.status("[bold blue]📚 Analyzing repository structure...") as status:
+        try:
+            contextly.sync()
+            console.print("\n[green]✓[/] Repository indexed successfully!")
+            console.print("[dim]Run 'contextly ask' to start querying your codebase[/]")
+        except Exception as e:
+            console.print(f"\n[red]✗[/] Error: {str(e)}")
+            raise typer.Exit(1)
 
 @model_app.command("list")
 def list_models() -> None:

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

@@ -5,10 +5,12 @@ Core functionality for code parsing and analysis.
 import difflib
 from pathlib import Path
 from typing import List, Dict, Any, Optional
-from ..llm import LLMManager
-from ..parsers.python import PythonParser
-from ..parsers.javascript import JavaScriptParser
-from ..parsers.config import ConfigParser
+from typing import Type
+from contextly.llm.manager import LLMManager
+from contextly.parsers.base import BaseParser
+from contextly.parsers.python import PythonParser
+from contextly.parsers.javascript import JavaScriptParser
+from contextly.parsers.config import ConfigParser
 
 class Parser:
     """Base class for parsing different file types."""
@@ -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.7/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.7/src/contextly/core/sync.py

@@ -0,0 +1,89 @@
+"""
+Repository synchronization and indexing functionality.
+"""
+
+from pathlib import Path
+from typing import List, Dict, Any, Iterator, Tuple
+import os
+from concurrent.futures import ProcessPoolExecutor, as_completed
+import multiprocessing
+from tqdm import tqdm
+
+from ..parsers.python import PythonParser
+from ..parsers.javascript import JavaScriptParser
+from ..parsers.config import ConfigParser
+
+class RepoSync:
+    """Handles repository scanning and indexing."""
+    
+    SUPPORTED_EXTENSIONS = {
+        # Code files
+        '.py': PythonParser,
+        '.js': JavaScriptParser,
+        '.jsx': JavaScriptParser,
+        '.ts': JavaScriptParser,
+        '.tsx': JavaScriptParser,
+        # Config files
+        '.json': ConfigParser,
+        '.yml': ConfigParser,
+        '.yaml': ConfigParser,
+        '.toml': ConfigParser,
+        '.env': ConfigParser,
+    }
+
+    IGNORED_DIRS = {'.git', '__pycache__', 'node_modules', 'venv', '.venv', 'dist', 'build'}
+    
+    def __init__(self, repo_path: Path):
+        self.repo_path = repo_path
+        self.num_workers = max(1, multiprocessing.cpu_count() - 1)
+        
+    def scan_files(self) -> List[Path]:
+        """Scan repository for supported files."""
+        files = []
+        for root, dirs, filenames in os.walk(self.repo_path):
+            # Skip ignored directories
+            dirs[:] = [d for d in dirs if d not in self.IGNORED_DIRS]
+            
+            root_path = Path(root)
+            for file in filenames:
+                file_path = root_path / file
+                if file_path.suffix in self.SUPPORTED_EXTENSIONS:
+                    files.append(file_path)
+        return files
+                    
+    def _process_file(self, file_path: Path) -> Tuple[str, Dict[str, Any]]:
+        """Process a single file and return its index data."""
+        parser_class = self.SUPPORTED_EXTENSIONS.get(file_path.suffix)
+        if not parser_class:
+            return str(file_path), {}
+            
+        try:
+            parser = parser_class()
+            result = parser.parse(file_path)
+            # Add file path to chunks for reference
+            for chunk in result.get('chunks', []):
+                chunk['file_path'] = str(file_path)
+            return str(file_path), result
+        except Exception as e:
+            return str(file_path), {'error': str(e)}
+
+    def index_repository(self) -> Dict[str, Any]:
+        """Build index of repository contents using parallel processing."""
+        files = self.scan_files()
+        total_files = len(files)
+        
+        if total_files == 0:
+            return {}
+            
+        index = {}
+        with ProcessPoolExecutor(max_workers=self.num_workers) as executor:
+            futures = [executor.submit(self._process_file, f) for f in files]
+            
+            with tqdm(total=total_files, desc="Analyzing files", unit="file") as pbar:
+                for future in as_completed(futures):
+                    file_path, result = future.result()
+                    if result and 'error' not in result:
+                        index[file_path] = result
+                    pbar.update(1)
+                    
+        return index

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

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

{contextly-0.1.0 → contextly-0.1.7}/src/contextly/llm/manager.py

@@ -14,10 +14,13 @@ class LLMManager:
     """Manages LLM providers and generates code explanations."""
     
     def __init__(self, model: Optional[str] = None):
+        """Initialize the LLM manager with the given model."""
         self.model_manager = ModelManager()
         self.providers: Dict[str, LLMProvider] = {}
         self.current_model = model or os.getenv('CONTEXTLY_MODEL', 'codellama')
+        self.initialized = False
         self._initialize_providers()
+        self.initialized = True
         
     def _initialize_providers(self) -> None:
         """Initialize LLM providers."""
@@ -27,6 +30,16 @@ class LLMManager:
         # Add OpenAI if key is available
         if os.getenv('OPENAI_API_KEY'):
             self.providers['openai'] = OpenAIProvider()
+        
+        # Ensure the default provider is available
+        self.ensure_default_provider()
+            
+    def ensure_default_provider(self) -> None:
+        """Ensure that a default provider is available."""
+        # Try to set up Ollama with codellama as default
+        if 'ollama' in self.providers:
+            if not self.model_manager.registry.get_model('codellama'):
+                self.model_manager.download_model('codellama', ModelProvider.OLLAMA)
             
     def get_available_provider(self) -> Optional[LLMProvider]:
         """Get the appropriate provider for the current model."""

{contextly-0.1.0 → contextly-0.1.7}/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."""
@@ -35,21 +35,54 @@ class ModelRegistry:
         self.models: Dict[str, ModelInfo] = {}
         self._load_models()
         
+    def check_model_status(self, model_name: str) -> Dict[str, Any]:
+        """Check if a model is installed and ready to use."""
+        import subprocess
+        status = {
+            'installed': False,
+            'ready': False,
+            'message': ''
+        }
+        
+        if model_name.startswith('codellama'):
+            # Check if Ollama is running
+            try:
+                result = subprocess.run(['ollama', 'list'], capture_output=True, text=True)
+                models = result.stdout.strip().split('\n')
+                status['installed'] = any(model_name in model for model in models)
+                if status['installed']:
+                    status['ready'] = True
+                    status['message'] = '✅ Model is installed and ready'
+                else:
+                    status['message'] = '⚠️ Model not found in Ollama'
+            except Exception:
+                status['message'] = '❌ Ollama not running or not installed'
+        return status
+
     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.7}/src/contextly/llm/ollama.py

@@ -12,6 +12,7 @@ class OllamaProvider(LLMProvider):
     
     DEFAULT_MODEL = "codellama"
     BASE_URL = "http://localhost:11434/api"
+    _model_checked = {}  # Class variable to track which models have been checked
     
     def __init__(self, model: str = DEFAULT_MODEL):
         self.model = model
@@ -19,6 +20,9 @@ class OllamaProvider(LLMProvider):
         
     def _ensure_model(self) -> None:
         """Ensure the model is downloaded and ready."""
+        if self.model in self._model_checked:
+            return
+            
         try:
             # Check if model exists
             response = requests.get(f"{self.BASE_URL}/tags")
@@ -34,6 +38,7 @@ class OllamaProvider(LLMProvider):
                     if pull_response.status_code != 200:
                         raise RuntimeError(f"Failed to pull model: {pull_response.text}")
                     print(f"{self.model} ready!")
+                self._model_checked[self.model] = True
         except Exception as e:
             raise RuntimeError(f"Failed to set up Ollama: {str(e)}")
     

{contextly-0.1.0 → contextly-0.1.7}/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.7/tests/conftest.py

@@ -0,0 +1,33 @@
+"""
+Configuration and fixtures for pytest.
+"""
+
+import os
+import pytest
+from pathlib import Path
+
+@pytest.fixture
+def test_repo_path():
+    """Get the path to the test repository."""
+    # Return the path to the contextly repository itself
+    return Path(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+@pytest.fixture(autouse=True)
+def setup_environment():
+    """Set up test environment variables."""
+    # Store existing environment variables
+    old_env = {}
+    if 'CONTEXTLY_MODEL' in os.environ:
+        old_env['CONTEXTLY_MODEL'] = os.environ['CONTEXTLY_MODEL']
+
+    # Set test environment variables
+    os.environ['CONTEXTLY_MODEL'] = 'codellama'
+    
+    yield
+
+    # Restore environment variables
+    for key in ['CONTEXTLY_MODEL']:
+        if key in old_env:
+            os.environ[key] = old_env[key]
+        elif key in os.environ:
+            del os.environ[key]

{contextly-0.1.0 → contextly-0.1.7}/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.7/tests/test_integration.py

@@ -0,0 +1,170 @@
+"""
+Integration tests for Contextly using its own codebase as test data.
+"""
+
+import os
+import pytest
+from pathlib import Path
+from contextly.app import Contextly
+from contextly.core.sync import RepoSync
+from contextly.core.embeddings import EmbeddingEngine
+from contextly.llm.manager import LLMManager
+from contextly.llm.ollama import OllamaProvider
+
+@pytest.fixture
+def repo_path():
+    """Get the path to the Contextly repository."""
+    # Get the tests directory and go up one level
+    return Path(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+@pytest.fixture
+def contextly_app(repo_path):
+    """Create a Contextly instance for testing."""
+    return Contextly(repo_path)
+
+def test_repo_sync(repo_path):
+    """Test repository synchronization with Contextly's own codebase."""
+    repo_sync = RepoSync(repo_path)
+    results = repo_sync.scan_files()
+    
+    # Verify essential files are found
+    python_files = [f for f in results if str(f).endswith('.py')]
+    assert len(python_files) > 0, "Should find Python files"
+    
+    # Verify core modules are found
+    core_files = {
+        'app.py',
+        'cli.py',
+        'embeddings.py',
+        'analyzer.py',
+        'sync.py'
+    }
+    found_files = {f.name for f in python_files}
+    assert core_files.intersection(found_files), "Should find core modules"
+
+def test_embedding_engine(repo_path):
+    """Test embedding engine with Contextly's codebase."""
+    engine = EmbeddingEngine(repo_path)
+    
+    # Test search functionality
+    results = engine.search("What is the main purpose of this codebase?")
+    assert results is not None
+    assert 'results' in results
+    assert len(results['results']) > 0
+    
+    # Verify search results contain relevant files
+    files = {r['file'] for r in results['results']}
+    assert any('README.md' in str(f) or 'app.py' in str(f) for f in files), \
+           "Should find relevant documentation or core files"
+
+def test_llm_manager():
+    """Test LLM manager functionality."""
+    manager = LLMManager(model='codellama')
+    assert manager.initialized
+    assert 'ollama' in manager.providers
+    
+    # Test available provider
+    provider = manager.get_available_provider()
+    assert provider is not None
+    assert isinstance(provider, OllamaProvider)
+    
+    # Test model is available
+    assert provider.is_available()
+    assert provider.model == 'codellama'
+    
+    # Test code explanation with simple code
+    code = '''def greet(name: str) -> str:
+    """Greet a user by name."""
+    return f"Hello, {name}!"'''
+    
+    context = {
+        'question': 'What does this function do?',
+        'code_snippets': [code],
+        'files': ['test.py']
+    }
+    
+    explanation = manager.explain_code(code, context)
+    assert explanation is not None
+    assert len(explanation) > 0
+
+def test_ollama_provider():
+    """Test Ollama LLM provider."""
+    provider = OllamaProvider()
+    
+    # Test model availability
+    assert provider.is_available(), "Ollama should be running"
+    
+    # Test response generation
+    prompt = "What is a code analyzer?"
+    response = provider.generate_response(prompt)
+    assert response is not None
+    assert len(response) > 0
+
+def test_contextly_ask(contextly_app):
+    """Test the ask functionality with real questions about the codebase."""
+    questions = [
+        "What is the purpose of the sync.py file?",
+        "How does the embedding engine work?",
+        "What LLM models are supported?",
+        "How are code snippets parsed?"
+    ]
+    
+    for question in questions:
+        result = contextly_app.ask(question)
+        assert result is not None
+        assert 'answer' in result or 'error' in result
+        
+        if 'answer' in result:
+            assert len(result['answer']) > 0
+            # Verify context is provided when available
+            if result.get('context'):
+                assert 'results' in result['context']
+                assert len(result['context']['results']) > 0
+
+def test_error_handling(contextly_app):
+    """Test error handling in various scenarios."""
+    # Test with empty question
+    with pytest.raises(Exception):
+        contextly_app.ask("")
+    
+    # Test with very long question
+    long_question = "what " * 1000
+    result = contextly_app.ask(long_question)
+    assert 'error' in result or 'answer' in result
+
+    # Test with invalid repository path
+    invalid_app = Contextly(Path("/nonexistent/path"))
+    result = invalid_app.ask("What is this?")
+    assert 'error' in result
+
+def test_code_analysis(contextly_app):
+    """Test code analysis functionality."""
+    # Get insights about a specific file
+    core_files = [
+        'app.py',
+        'cli.py',
+        'embeddings.py'
+    ]
+    
+    for file in core_files:
+        question = f"What does {file} do?"
+        result = contextly_app.ask(question)
+        assert result is not None
+        assert 'answer' in result
+        assert len(result['answer']) > 0
+
+def test_multi_file_context(contextly_app):
+    """Test handling questions that require context from multiple files."""
+    questions = [
+        "How does the CLI interface interact with the core application?",
+        "What is the relationship between embeddings.py and analyzer.py?",
+        "How do the different LLM providers work together?"
+    ]
+    
+    for question in questions:
+        result = contextly_app.ask(question)
+        assert result is not None
+        assert 'answer' in result
+        if result.get('context'):
+            files = {r['file'] for r in result['context']['results']}
+            assert len(files) > 1, "Should reference multiple files for complex questions"

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()

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

@@ -1,66 +0,0 @@
-"""
-Repository synchronization and indexing functionality.
-"""
-
-from pathlib import Path
-from typing import List, Dict, Any, Iterator
-import os
-
-from ..parsers.python import PythonParser
-from ..parsers.javascript import JavaScriptParser
-from ..parsers.config import ConfigParser
-
-class RepoSync:
-    """Handles repository scanning and indexing."""
-    
-    SUPPORTED_EXTENSIONS = {
-        '.py', '.js', '.json', '.yml', '.yaml', 
-        '.env', '.toml', '.md', '.txt'
-    }
-    
-    def __init__(self, repo_path: Path):
-        self.repo_path = repo_path
-        
-    def scan_files(self) -> Iterator[Path]:
-        """Scan repository for supported files."""
-        for root, _, files in os.walk(self.repo_path):
-            root_path = Path(root)
-            if '.git' in root_path.parts:
-                continue
-                
-            for file in files:
-                file_path = root_path / file
-                if file_path.suffix in self.SUPPORTED_EXTENSIONS:
-                    yield file_path
-                    
-    def index_repository(self) -> Dict[str, Any]:
-        """Build index of repository contents."""
-        index = {}
-        parsers = {
-            '.py': PythonParser(),
-            '.js': JavaScriptParser(),
-            '.jsx': JavaScriptParser(),
-            '.ts': JavaScriptParser(),
-            '.tsx': JavaScriptParser(),
-            '.json': ConfigParser(),
-            '.yml': ConfigParser(),
-            '.yaml': ConfigParser(),
-            '.toml': ConfigParser(),
-            '.env': ConfigParser(),
-        }
-        
-        for file_path in self.scan_files():
-            ext = file_path.suffix
-            parser = parsers.get(ext)
-            
-            if parser:
-                try:
-                    result = parser.parse(file_path)
-                    # Add file path to chunks for reference
-                    for chunk in result.get('chunks', []):
-                        chunk['file_path'] = str(file_path)
-                    index[str(file_path)] = result
-                except Exception as e:
-                    print(f"Error parsing {file_path}: {e}")
-                    
-        return index