contextly 0.1.4__tar.gz → 0.1.7__tar.gz

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

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: contextly
-Version: 0.1.4
+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.4 → contextly-0.1.7}/pyproject.toml

@@ -4,9 +4,9 @@ build-backend = "hatchling.build"
 
 [project]
 name = "contextly"
-version = "0.1.4"
+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.4 → 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.4 → contextly-0.1.7}/src/contextly/core/analyzer.py

@@ -6,11 +6,11 @@ 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
+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."""

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.4 → 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.4 → contextly-0.1.7}/src/contextly/llm/models.py

@@ -35,6 +35,30 @@ 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."""
         try:

{contextly-0.1.4 → 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.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.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.4/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

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

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