contextly 0.1.0__py3-none-any.whl

contextly/__init__.py

@@ -0,0 +1,5 @@
+"""
+Contextly - The AI Context Engine for Developers
+"""
+
+__version__ = "0.1.0"

contextly/app.py

@@ -0,0 +1,85 @@
+"""
+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/cli.py

@@ -0,0 +1,201 @@
+"""
+Main CLI interface for Contextly
+"""
+
+import typer
+from rich import print
+from rich.console import Console
+from rich.markdown import Markdown
+from rich.panel import Panel
+from rich.syntax import Syntax
+from typing import Optional
+from pathlib import Path
+
+from .app import Contextly
+
+console = Console()
+
+app = typer.Typer(
+    name="contextly",
+    help="AI Context Engine for Developers",
+    add_completion=False,
+)
+
+model_app = typer.Typer(help="Manage LLM models")
+app.add_typer(model_app, name="model")
+
+def get_contextly(repo_path: Optional[Path] = None) -> Contextly:
+    """Get or create Contextly instance."""
+    return Contextly(repo_path)
+
+@app.command()
+def ask(
+    question: str = typer.Argument(..., help="Your question about the codebase"),
+) -> None:
+    """Ask natural language questions about your codebase."""
+    print("🔍 Searching for answer...")
+    result = get_contextly().ask(question)
+    
+    # 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']:
+            console.print(Panel(
+                Syntax(
+                    snippet['content'],
+                    "python",  # TODO: Detect language from file extension
+                    theme="monokai",
+                    line_numbers=True
+                ),
+                title=f"📄 {snippet['file']}",
+                border_style="dim"
+            ))
+
+@app.command()
+def explain(
+    location: str = typer.Argument(..., help="File location (e.g., src/auth.py:52)"),
+) -> None:
+    """Get human-readable explanation of code at specific location."""
+    print("📝 Analyzing code...")
+    explanation = get_contextly().explain(location)
+    print(explanation)
+
+@app.command()
+def search(
+    term: str = typer.Argument(..., help="Search term"),
+) -> None:
+    """Semantic search across your codebase."""
+    print("🔎 Searching codebase...")
+    results = get_contextly().search(term)
+    
+    if not results['results']:
+        print("❌ No matching code found")
+        return
+        
+    print(f"\n✨ Found {len(results['results'])} matches:\n")
+    for result in results['results']:
+        console.print(Panel(
+            Syntax(
+                result['content'],
+                "python",  # TODO: Detect language from file extension
+                theme="monokai",
+                line_numbers=True
+            ),
+            title=f"📄 {result['file']} (Score: {result['score']:.2f})",
+            border_style="blue"
+        ))
+
+@app.command()
+def diff(
+    path1: Path = typer.Argument(..., help="First file path"),
+    path2: Path = typer.Argument(..., help="Second file path"),
+) -> None:
+    """Compare and explain differences between configuration files."""
+    print("⚡ Analyzing differences...")
+    differences = get_contextly().diff(path1, path2)
+    
+    # Print differences
+    if not differences['differences']:
+        print("✅ Files are identical")
+        return
+        
+    # Print unified diff
+    console.print("\n📊 Diff:")
+    console.print(Panel(
+        Syntax(
+            "\n".join(differences['unified_diff']),
+            "diff",
+            theme="monokai"
+        ),
+        border_style="yellow"
+    ))
+    
+    # Print value differences
+    console.print("\n🔍 Key Differences:")
+    for diff in differences['differences']:
+        console.print(
+            f"• {diff['key']}:\n"
+            f"  - {path1}: {diff['file1_value']!r}\n"
+            f"  + {path2}: {diff['file2_value']!r}\n"
+        )
+
+@app.command()
+def sync(
+    path: Optional[Path] = typer.Argument(
+        None, help="Path to repository (defaults to current directory)"
+    ),
+) -> None:
+    """Build or rebuild the local embedding index."""
+    print("🔄 Syncing repository...")
+    get_contextly(path).sync()
+    print("✨ Repository indexed successfully!")
+
+@model_app.command("list")
+def list_models() -> None:
+    """List available models."""
+    ctx = get_contextly()
+    models = ctx.llm_manager.list_models()
+    
+    console.print("\n🤖 Available Models:")
+    for model in models:
+        status_color = "green" if model['status'] == 'available' else "yellow"
+        console.print(
+            f"\n[bold]{model['name']}[/bold] "
+            f"([{status_color}]{model['status']}[/{status_color}])")
+        if model.get('description'):
+            console.print(f"  {model['description']}")
+        console.print(f"  Provider: {model['provider']}")
+
+@model_app.command("use")
+def use_model(
+    model_name: str = typer.Argument(..., help="Name of the model to use")
+) -> None:
+    """Set the model to use for code analysis."""
+    ctx = get_contextly()
+    print(f"🔍 Setting up model {model_name}...")
+    
+    if ctx.llm_manager.set_model(model_name):
+        print(f"✅ Now using {model_name}")
+    else:
+        print(f"❌ Failed to set up {model_name}")
+
+@model_app.command("download")
+def download_model(
+    model_name: str = typer.Argument(..., help="Name of the model to download"),
+    provider: str = typer.Option(
+        "ollama",
+        help="Model provider (ollama, huggingface, custom)"
+    ),
+    url: Optional[str] = typer.Option(
+        None,
+        help="URL for custom model download"
+    )
+) -> None:
+    """Download a new model."""
+    from contextly.llm.models import ModelProvider
+    
+    ctx = get_contextly()
+    print(f"💾 Downloading {model_name}...")
+    
+    try:
+        provider_enum = ModelProvider(provider)
+        if ctx.llm_manager.model_manager.download_model(
+            model_name,
+            provider_enum,
+            url=url
+        ):
+            print(f"✅ Successfully downloaded {model_name}")
+        else:
+            print(f"❌ Failed to download {model_name}")
+    except ValueError:
+        print(f"❌ Unknown provider: {provider}")
+
+if __name__ == "__main__":
+    app()

contextly/core/analyzer.py

@@ -0,0 +1,111 @@
+"""
+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
+
+class Parser:
+    """Base class for parsing different file types."""
+    
+    def __init__(self, repo_path: Path):
+        self.repo_path = repo_path
+        
+    def parse(self, file_path: Path) -> Dict[str, Any]:
+        """Parse a file and return its content and metadata."""
+        raise NotImplementedError
+        
+class CodeAnalyzer:
+    """Analyzes code and configuration files."""
+    
+    def __init__(self, repo_path: Path):
+        self.repo_path = repo_path
+        self.llm = LLMManager()
+        
+        # Initialize parsers
+        self.parsers = {
+            '.py': PythonParser(),
+            '.js': JavaScriptParser(),
+            '.jsx': JavaScriptParser(),
+            '.ts': JavaScriptParser(),
+            '.tsx': JavaScriptParser(),
+            '.json': ConfigParser(),
+            '.yml': ConfigParser(),
+            '.yaml': ConfigParser(),
+            '.toml': ConfigParser(),
+            '.env': ConfigParser(),
+        }
+        
+    def _get_parser(self, file_path: str) -> Optional[Parser]:
+        """Get appropriate parser for a file type."""
+        ext = Path(file_path).suffix
+        return self.parsers.get(ext)
+        
+    def explain_code(self, file_path: str, line_number: int) -> str:
+        """Generate explanation for code at specific location."""
+        parser = self._get_parser(file_path)
+        if not parser:
+            return f"Unsupported file type: {file_path}"
+            
+        # Parse file and extract context around line
+        result = parser.parse(Path(file_path))
+        
+        # Find chunk containing the line
+        target_chunk = None
+        for chunk in result['chunks']:
+            if chunk['start_line'] <= line_number <= chunk['end_line']:
+                target_chunk = chunk
+                break
+                
+        if not target_chunk:
+            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)
+        
+        return explanation
+        
+    def compare_configs(self, path1: Path, path2: Path) -> Dict[str, Any]:
+        """Compare two configuration files and detect differences."""
+        parser = ConfigParser()
+        
+        # Parse both files
+        result1 = parser.parse(path1)
+        result2 = parser.parse(path2)
+        
+        # Compare parsed values
+        all_keys = set(result1['parsed'].keys()) | set(result2['parsed'].keys())
+        diffs = []
+        
+        for key in sorted(all_keys):
+            val1 = result1['parsed'].get(key)
+            val2 = result2['parsed'].get(key)
+            
+            if val1 != val2:
+                diffs.append({
+                    'key': key,
+                    'file1_value': val1,
+                    'file2_value': val2
+                })
+                
+        # Compare raw content for visual diff
+        diff = list(difflib.unified_diff(
+            result1['content'].splitlines(),
+            result2['content'].splitlines(),
+            fromfile=str(path1),
+            tofile=str(path2),
+            lineterm=''
+        ))
+        
+        return {
+            'file1_type': result1['file_type'],
+            'file2_type': result2['file_type'],
+            'differences': diffs,
+            'unified_diff': diff
+        }

contextly/core/embeddings.py

@@ -0,0 +1,109 @@
+"""
+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/core/sync.py

@@ -0,0 +1,66 @@
+"""
+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/llm/base.py

@@ -0,0 +1,19 @@
+"""
+Abstract base class for LLM providers.
+"""
+
+from abc import ABC, abstractmethod
+from typing import Dict, Any, Optional
+
+class LLMProvider(ABC):
+    """Base class for LLM providers."""
+    
+    @abstractmethod
+    def generate_response(self, prompt: str, **kwargs) -> str:
+        """Generate a response from the LLM."""
+        pass
+        
+    @abstractmethod
+    def is_available(self) -> bool:
+        """Check if this LLM provider is available."""
+        pass