clapp-pm 1.0.16__py3-none-any.whl → 1.0.18__py3-none-any.whl

cache_manager.py

@@ -0,0 +1,376 @@
+#!/usr/bin/env python3
+"""
+cache_manager.py - Performans Optimizasyonu ve Önbellekleme Sistemi
+
+Bu modül clapp'in performansını artırmak için:
+- Paket meta verilerini önbellekleme
+- Registry verilerini önbellekleme
+- Dosya checksum'larını önbellekleme
+- Akıllı cache yönetimi
+- Paralel indirme desteği
+"""
+
+import os
+import json
+import hashlib
+import pickle
+import threading
+import time
+from pathlib import Path
+from typing import Dict, Any, Optional, List, Tuple
+from datetime import datetime, timedelta
+import concurrent.futures
+import requests
+from functools import wraps
+
+class CacheManager:
+    """Akıllı önbellekleme yöneticisi"""
+    
+    def __init__(self, cache_dir: Optional[str] = None):
+        """
+        CacheManager başlatıcısı
+        
+        Args:
+            cache_dir: Cache dizini (varsayılan: ~/.clapp/cache)
+        """
+        if cache_dir is None:
+            cache_dir = os.path.join(os.path.expanduser("~"), ".clapp", "cache")
+        
+        self.cache_dir = Path(cache_dir)
+        self.cache_dir.mkdir(parents=True, exist_ok=True)
+        
+        # Cache türleri
+        self.metadata_cache = self.cache_dir / "metadata"
+        self.registry_cache = self.cache_dir / "registry"
+        self.checksum_cache = self.cache_dir / "checksums"
+        self.download_cache = self.cache_dir / "downloads"
+        
+        # Cache dizinlerini oluştur
+        for cache_path in [self.metadata_cache, self.registry_cache, 
+                          self.checksum_cache, self.download_cache]:
+            cache_path.mkdir(exist_ok=True)
+        
+        # Cache istatistikleri
+        self.stats = {
+            "hits": 0,
+            "misses": 0,
+            "evictions": 0,
+            "size": 0
+        }
+        
+        # Thread-safe cache
+        self._lock = threading.Lock()
+    
+    def _get_cache_key(self, key: str, cache_type: str = "metadata") -> Path:
+        """Cache anahtarı için dosya yolu oluşturur"""
+        if cache_type == "metadata":
+            return self.metadata_cache / f"{key}.json"
+        elif cache_type == "registry":
+            return self.registry_cache / f"{key}.json"
+        elif cache_type == "checksum":
+            return self.checksum_cache / f"{key}.txt"
+        elif cache_type == "download":
+            return self.download_cache / f"{key}.zip"
+        else:
+            raise ValueError(f"Geçersiz cache türü: {cache_type}")
+    
+    def get(self, key: str, cache_type: str = "metadata", max_age: int = 3600) -> Optional[Any]:
+        """
+        Cache'den veri alır
+        
+        Args:
+            key: Cache anahtarı
+            cache_type: Cache türü
+            max_age: Maksimum yaş (saniye)
+            
+        Returns:
+            Cache'lenmiş veri veya None
+        """
+        cache_file = self._get_cache_key(key, cache_type)
+        
+        if not cache_file.exists():
+            self.stats["misses"] += 1
+            return None
+        
+        # Dosya yaşını kontrol et
+        file_age = time.time() - cache_file.stat().st_mtime
+        if file_age > max_age:
+            cache_file.unlink()
+            self.stats["misses"] += 1
+            return None
+        
+        try:
+            with self._lock:
+                if cache_type in ["metadata", "registry"]:
+                    with open(cache_file, 'r', encoding='utf-8') as f:
+                        data = json.load(f)
+                elif cache_type == "checksum":
+                    with open(cache_file, 'r', encoding='utf-8') as f:
+                        data = f.read().strip()
+                else:
+                    # Binary dosyalar için pickle kullan
+                    with open(cache_file, 'rb') as f:
+                        data = pickle.load(f)
+            
+            self.stats["hits"] += 1
+            return data
+            
+        except Exception as e:
+            print(f"Cache okuma hatası: {e}")
+            cache_file.unlink()
+            self.stats["misses"] += 1
+            return None
+    
+    def set(self, key: str, data: Any, cache_type: str = "metadata") -> bool:
+        """
+        Cache'e veri kaydeder
+        
+        Args:
+            key: Cache anahtarı
+            data: Kaydedilecek veri
+            cache_type: Cache türü
+            
+        Returns:
+            Başarılıysa True
+        """
+        cache_file = self._get_cache_key(key, cache_type)
+        
+        try:
+            with self._lock:
+                if cache_type in ["metadata", "registry"]:
+                    with open(cache_file, 'w', encoding='utf-8') as f:
+                        json.dump(data, f, indent=2, ensure_ascii=False)
+                elif cache_type == "checksum":
+                    with open(cache_file, 'w', encoding='utf-8') as f:
+                        f.write(str(data))
+                else:
+                    # Binary dosyalar için pickle kullan
+                    with open(cache_file, 'wb') as f:
+                        pickle.dump(data, f)
+            
+            return True
+            
+        except Exception as e:
+            print(f"Cache yazma hatası: {e}")
+            return False
+    
+    def delete(self, key: str, cache_type: str = "metadata") -> bool:
+        """Cache'den veri siler"""
+        cache_file = self._get_cache_key(key, cache_type)
+        
+        try:
+            if cache_file.exists():
+                cache_file.unlink()
+                return True
+            return False
+        except Exception:
+            return False
+    
+    def clear(self, cache_type: Optional[str] = None) -> int:
+        """
+        Cache'i temizler
+        
+        Args:
+            cache_type: Temizlenecek cache türü (None ise tümü)
+            
+        Returns:
+            Silinen dosya sayısı
+        """
+        deleted_count = 0
+        
+        if cache_type:
+            cache_path = self._get_cache_key("", cache_type).parent
+            if cache_path.exists():
+                for file in cache_path.iterdir():
+                    if file.is_file():
+                        file.unlink()
+                        deleted_count += 1
+        else:
+            # Tüm cache'leri temizle
+            for cache_path in [self.metadata_cache, self.registry_cache, 
+                              self.checksum_cache, self.download_cache]:
+                if cache_path.exists():
+                    for file in cache_path.iterdir():
+                        if file.is_file():
+                            file.unlink()
+                            deleted_count += 1
+        
+        return deleted_count
+    
+    def get_stats(self) -> Dict[str, Any]:
+        """Cache istatistiklerini döndürür"""
+        total_size = 0
+        
+        # Cache boyutunu hesapla
+        for cache_path in [self.metadata_cache, self.registry_cache, 
+                          self.checksum_cache, self.download_cache]:
+            if cache_path.exists():
+                for file in cache_path.iterdir():
+                    if file.is_file():
+                        total_size += file.stat().st_size
+        
+        return {
+            **self.stats,
+            "size_bytes": total_size,
+            "size_mb": round(total_size / (1024 * 1024), 2),
+            "hit_rate": round(self.stats["hits"] / max(1, self.stats["hits"] + self.stats["misses"]) * 100, 2)
+        }
+    
+    def calculate_checksum(self, file_path: str) -> str:
+        """Dosyanın SHA-256 checksum'unu hesaplar ve cache'ler"""
+        cache_key = hashlib.md5(file_path.encode()).hexdigest()
+        cached_checksum = self.get(cache_key, "checksum", max_age=86400)  # 24 saat
+        
+        if cached_checksum:
+            return cached_checksum
+        
+        # Checksum hesapla
+        sha256_hash = hashlib.sha256()
+        with open(file_path, "rb") as f:
+            for chunk in iter(lambda: f.read(4096), b""):
+                sha256_hash.update(chunk)
+        
+        checksum = sha256_hash.hexdigest()
+        self.set(cache_key, checksum, "checksum")
+        
+        return checksum
+    
+    def cache_package_metadata(self, package_path: str, metadata: Dict[str, Any]) -> bool:
+        """Paket meta verilerini cache'ler"""
+        cache_key = hashlib.md5(package_path.encode()).hexdigest()
+        return self.set(cache_key, metadata, "metadata")
+    
+    def get_cached_package_metadata(self, package_path: str) -> Optional[Dict[str, Any]]:
+        """Cache'lenmiş paket meta verilerini alır"""
+        cache_key = hashlib.md5(package_path.encode()).hexdigest()
+        return self.get(cache_key, "metadata", max_age=3600)  # 1 saat
+    
+    def cache_registry_data(self, registry_url: str, data: List[Dict[str, Any]]) -> bool:
+        """Registry verilerini cache'ler"""
+        cache_key = hashlib.md5(registry_url.encode()).hexdigest()
+        return self.set(cache_key, data, "registry")
+    
+    def get_cached_registry_data(self, registry_url: str) -> Optional[List[Dict[str, Any]]]:
+        """Cache'lenmiş registry verilerini alır"""
+        cache_key = hashlib.md5(registry_url.encode()).hexdigest()
+        return self.get(cache_key, "registry", max_age=1800)  # 30 dakika
+
+class ParallelDownloader:
+    """Paralel indirme yöneticisi"""
+    
+    def __init__(self, max_workers: int = 4):
+        """
+        ParallelDownloader başlatıcısı
+        
+        Args:
+            max_workers: Maksimum paralel işçi sayısı
+        """
+        self.max_workers = max_workers
+        self.session = requests.Session()
+        self.session.headers.update({
+            'User-Agent': 'clapp-package-manager/1.0'
+        })
+    
+    def download_file(self, url: str, destination: str) -> Tuple[bool, str]:
+        """Tek dosya indirir"""
+        try:
+            response = self.session.get(url, stream=True, timeout=30)
+            response.raise_for_status()
+            
+            with open(destination, 'wb') as f:
+                for chunk in response.iter_content(chunk_size=8192):
+                    f.write(chunk)
+            
+            return True, f"Dosya indirildi: {destination}"
+            
+        except Exception as e:
+            return False, f"İndirme hatası: {str(e)}"
+    
+    def download_files_parallel(self, download_tasks: List[Tuple[str, str]]) -> List[Tuple[bool, str]]:
+        """
+        Birden fazla dosyayı paralel indirir
+        
+        Args:
+            download_tasks: [(url, destination), ...] listesi
+            
+        Returns:
+            [(success, message), ...] listesi
+        """
+        results = []
+        
+        with concurrent.futures.ThreadPoolExecutor(max_workers=self.max_workers) as executor:
+            # İndirme görevlerini başlat
+            future_to_task = {
+                executor.submit(self.download_file, url, dest): (url, dest)
+                for url, dest in download_tasks
+            }
+            
+            # Sonuçları topla
+            for future in concurrent.futures.as_completed(future_to_task):
+                task = future_to_task[future]
+                try:
+                    result = future.result()
+                    results.append(result)
+                except Exception as e:
+                    results.append((False, f"İndirme hatası: {str(e)}"))
+        
+        return results
+
+# Cache decorator
+def cached(max_age: int = 3600, cache_type: str = "metadata"):
+    """Cache decorator'ı"""
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            # Cache anahtarı oluştur
+            cache_key = f"{func.__name__}_{hash(str(args) + str(sorted(kwargs.items())))}"
+            
+            # Cache manager oluştur
+            cache_manager = CacheManager()
+            
+            # Cache'den kontrol et
+            cached_result = cache_manager.get(cache_key, cache_type, max_age)
+            if cached_result is not None:
+                return cached_result
+            
+            # Fonksiyonu çalıştır
+            result = func(*args, **kwargs)
+            
+            # Sonucu cache'le
+            cache_manager.set(cache_key, result, cache_type)
+            
+            return result
+        return wrapper
+    return decorator
+
+# Yardımcı fonksiyonlar
+def create_cache_manager() -> CacheManager:
+    """Varsayılan ayarlarla CacheManager oluşturur"""
+    return CacheManager()
+
+def create_parallel_downloader(max_workers: int = 4) -> ParallelDownloader:
+    """ParallelDownloader oluşturur"""
+    return ParallelDownloader(max_workers)
+
+def get_cache_stats() -> Dict[str, Any]:
+    """Cache istatistiklerini alır"""
+    cache_manager = create_cache_manager()
+    return cache_manager.get_stats()
+
+def clear_all_caches() -> int:
+    """Tüm cache'leri temizler"""
+    cache_manager = create_cache_manager()
+    return cache_manager.clear()
+
+def download_packages_parallel(package_urls: List[str], destination_dir: str) -> List[Tuple[bool, str]]:
+    """Paketleri paralel indirir"""
+    downloader = create_parallel_downloader()
+    
+    # İndirme görevlerini hazırla
+    download_tasks = []
+    for url in package_urls:
+        filename = os.path.basename(url)
+        destination = os.path.join(destination_dir, filename)
+        download_tasks.append((url, destination))
+    
+    return downloader.download_files_parallel(download_tasks) 

{clapp_pm-1.0.16.data → clapp_pm-1.0.18.data}/data/version.json

@@ -1,6 +1,6 @@
 {
   "app_name": "clapp",
-  "version": "1.0.16",
+  "version": "1.0.18",
   "author": "Melih Burak Memiş",
   "description": "Basit ve güçlü paket yöneticisi",
   "source": "https://github.com/melihburak/clapp",

{clapp_pm-1.0.16.dist-info → clapp_pm-1.0.18.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clapp-pm
-Version: 1.0.16
+Version: 1.0.18
 Summary: Lightweight cross-language app manager for Python and Lua
 Home-page: https://github.com/mburakmmm/clapp
 Author: Melih Burak Memiş

{clapp_pm-1.0.16.dist-info → clapp_pm-1.0.18.dist-info}/RECORD

@@ -1,3 +1,4 @@
+cache_manager.py,sha256=HdQ3vnZO_YP0vyotzjP5wozltVNgkJAxrvYFXhGLGCI,13287
 check_env.py,sha256=9O8CrdWGcxd_WBV5bsAAZG9iAaiO-nGYDYY-gYZ9G3M,4132
 clapp_core.py,sha256=5tkzt7J4GKSv7Chv5Zoe9N0dv_sWlYGqYxmIn3dhEPY,1764
 clean_command.py,sha256=nmzitkdNo0Ovgi-tGPUxa9mkAIFzwEzGNaTm82MUdvw,6806
@@ -8,18 +9,21 @@ info_command.py,sha256=b74Pl1-x_PSezALx-lS3FkEcVNTF7a9McTKk5XTDhjM,5629
 install_command.py,sha256=1Ogy_4nOsnLXzoUBys9yeLf5jKkGv9C40wuGZo2COC0,9445
 installer.py,sha256=EkQ5Z1Cq_Z5u_Ssv2Nc8hryI5E97x4D1QVjSqEHe0dE,10619
 list_command.py,sha256=qbeocvrg2eXRklxbYS3audQhYHGXTlMBk_tNh1cMxd0,8391
-main.py,sha256=qunqz-FMwmnyat5bLP3YpZLkyCcEgL7vuUsY3UTDJpc,14493
+main.py,sha256=sDbezA6-irQ8QDRvA8wi7rkfyx73Dn7MWMCmlDiTKbI,23590
 manifest_schema.py,sha256=IxfKuYgcIhILJrDMOm5vjSJn2jp7hPpUoxtjPMCPvbE,2201
 manifest_validator.py,sha256=MTI6c_sYfVakQ6aQUu5_qkukTh4H1FcSrT4uRdE6xIg,7990
 package_registry.py,sha256=Rco15cvz-6lpCEDdCzwGZNCKtvVhlFIsEPy-WFAESMM,4233
 package_runner.py,sha256=jbn9OJDU4p-v63dO66C5EBSbT0dlWQIjtp7x2VE6lU0,2758
+package_signing.py,sha256=CdJKLNQLpQJmckgatOnnYDl_4Ve_U1tgWFlzvhXLhq8,12991
 post_install_hint.py,sha256=wjMPCgRurZiGu6hv_se-XA36KqBCdeYdRCD1q7FrJzQ,4918
 publish_command.py,sha256=P05AFbu_mxcc1yAiwShN5Yi9PX1o_7TFXD1mowJcqJE,8589
 remote_registry.py,sha256=rPBIM_ESXUt0br5cARQ4YbzUoTda0G4e1KGzfyYMbpQ,8235
+smart_search.py,sha256=R5O5CDXqlQc-N-6R6D5k36_-arCB-wnKfmWr5zMYWUI,15741
 uninstall_command.py,sha256=rQYbZ-XMw8Xxw1fmgGdDaBQmgBGqyJ_rTBZkvEV5HV0,7066
 validate_command.py,sha256=idaujErzrwuZNT6DYCVTVwZqBDEEi1GTxIXAGBgKMKM,7623
-version.py,sha256=RvPHXeGwIC817pSMDlUZ7vihz2mS2jogbUOHy0CTets,224
+version.py,sha256=v2-Js_gwcyS6cS3GUE0svFpltW1QaNxMWqolPkiYckc,224
 version_command.py,sha256=DZuYWtohSeM5PJNYCflBy36_k0vex3tYV2C8ixEA9ho,4259
+version_manager.py,sha256=fpC7jxhIW1wZhJ9IkVwyqkgJN4mhBjUUbaLefXLDMiM,11423
 where_command.py,sha256=TcLoXLGmrPSHQuvlceVuuKBsfeadIwz-E0G_5okH14g,6420
 backup_current/build_index.py,sha256=8yKrUnh1Wre31Jt-kgMRxLiW6AIWpmZoNR4wEwAsP2E,4195
 backup_current/check_env.py,sha256=5DJwdALpRe1TLbzF_Zta-zD312J065-pPmsJZ17xRDg,4425
@@ -56,16 +60,16 @@ clapp-packages-repo/packages/test-app/main.py,sha256=rN4Zo9u53bIVjcUlul059knx6v-
 clapp-packages-repo/packages/test-app/manifest.json,sha256=kJe4sjYdPRNZD5hEeca80jj3lxeEWBMJoZ59RW7tiKI,118
 clapp-packages-repo/packages/test-app2/main.py,sha256=lHkbjTmehFY4VuYYF2dYiVBH7W0oqHHeY0I5W85iPTY,35
 clapp-packages-repo/packages/test-app2/manifest.json,sha256=vshXJrtRxBc_ISM6E8KT5BSmveMbjWszenlgxgSN86w,121
-clapp_pm-1.0.16.data/data/version.json,sha256=rQ7rkigbJXo2-CBwIzoBLwaHzpP90uR0nnJ0uQ18A18,239
-clapp_pm-1.0.16.dist-info/licenses/LICENSE,sha256=_hryv9pKR6udRexceUYuoYCJGmYBz7e-vRuFWmm38UY,1075
+clapp_pm-1.0.18.data/data/version.json,sha256=vjVSIoBpTGhKmQn_whZcLBQvZROYh0bwmu0koOga7GE,239
+clapp_pm-1.0.18.dist-info/licenses/LICENSE,sha256=_hryv9pKR6udRexceUYuoYCJGmYBz7e-vRuFWmm38UY,1075
 packages/hello-python/main.py,sha256=Dy-Ov-Vumj8oQYI6qKWU6fIKD0gCB8b7KzAJVrGyLMg,1429
 packages/hello-python/manifest.json,sha256=fJOVJk_2rwpRJ6IeWMPieklJD3gAR279jvuqRH69s90,179
 packages/test-app/main.py,sha256=rN4Zo9u53bIVjcUlul059knx6v-2Cd1MFftPS57FIRU,33
 packages/test-app/manifest.json,sha256=kJe4sjYdPRNZD5hEeca80jj3lxeEWBMJoZ59RW7tiKI,118
 packages/test-app2/main.py,sha256=lHkbjTmehFY4VuYYF2dYiVBH7W0oqHHeY0I5W85iPTY,35
 packages/test-app2/manifest.json,sha256=vshXJrtRxBc_ISM6E8KT5BSmveMbjWszenlgxgSN86w,121
-clapp_pm-1.0.16.dist-info/METADATA,sha256=6B6MJ3imHG36YckFdyAyF_mL95glnLJsYcJuvAd9v38,3980
-clapp_pm-1.0.16.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-clapp_pm-1.0.16.dist-info/entry_points.txt,sha256=7j-3pQVpQfnaVzUV83g7zlCA30ePlnXkhHLAGGz9xrQ,36
-clapp_pm-1.0.16.dist-info/top_level.txt,sha256=xNs9KmF0kILnBLPWg1VS_nhG2G0lbzy06AInJkq1Ilo,374
-clapp_pm-1.0.16.dist-info/RECORD,,
+clapp_pm-1.0.18.dist-info/METADATA,sha256=CV70wSEfsj7lpDkbQqqNBmzwIjqoAy-1Zech_-SRp8c,3980
+clapp_pm-1.0.18.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+clapp_pm-1.0.18.dist-info/entry_points.txt,sha256=7j-3pQVpQfnaVzUV83g7zlCA30ePlnXkhHLAGGz9xrQ,36
+clapp_pm-1.0.18.dist-info/top_level.txt,sha256=WMvIV8nU6pIZGL4xalAcOVmjBDjI6NoCd_Os3rdT9bI,433
+clapp_pm-1.0.18.dist-info/RECORD,,

{clapp_pm-1.0.16.dist-info → clapp_pm-1.0.18.dist-info}/top_level.txt

@@ -1,4 +1,5 @@
 backup_current
+cache_manager
 check_env
 clapp-packages-repo
 clapp_core
@@ -15,12 +16,15 @@ manifest_schema
 manifest_validator
 package_registry
 package_runner
+package_signing
 packages
 post_install_hint
 publish_command
 remote_registry
+smart_search
 uninstall_command
 validate_command
 version
 version_command
+version_manager
 where_command

main.py

@@ -32,6 +32,12 @@ from clean_command import run_clean
 from where_command import locate_app_path, list_all_app_locations
 from version_command import print_version, print_detailed_version
 
+# Yeni güvenlik ve performans modülleri
+from package_signing import sign_package_file, verify_package_file, check_package_security
+from version_manager import check_app_updates, get_app_latest_version, increment_app_version
+from cache_manager import get_cache_stats, clear_all_caches, download_packages_parallel
+from smart_search import search_packages, get_search_suggestions, get_search_analytics, clear_search_history
+
 # Yeni publish.cursorrules komutları
 from publish_command import publish_app
 from install_command import install_app
@@ -173,6 +179,34 @@ def main():
     version_parser.add_argument('--json', action='store_true', help='JSON formatında')
     version_parser.add_argument('--detailed', action='store_true', help='Detaylı bilgi')
     
+    # Güvenlik komutları
+    security_parser = subparsers.add_parser('security', help='Paket güvenlik işlemleri')
+    security_parser.add_argument('action', choices=['sign', 'verify', 'check'], help='Güvenlik işlemi')
+    security_parser.add_argument('package_path', help='Paket dosyası yolu')
+    security_parser.add_argument('--signature', help='İmza dosyası yolu (verify için)')
+    
+    # Versiyon yönetimi komutları
+    update_parser = subparsers.add_parser('update', help='Versiyon yönetimi')
+    update_parser.add_argument('action', choices=['check', 'increment'], help='İşlem türü')
+    update_parser.add_argument('--app', help='Uygulama adı')
+    update_parser.add_argument('--type', choices=['major', 'minor', 'patch'], default='patch', help='Artırma tipi')
+    
+    # Cache yönetimi komutları
+    cache_parser = subparsers.add_parser('cache', help='Cache yönetimi')
+    cache_parser.add_argument('action', choices=['stats', 'clear', 'download'], help='Cache işlemi')
+    cache_parser.add_argument('--urls', nargs='+', help='İndirilecek URL\'ler (download için)')
+    cache_parser.add_argument('--dest', help='Hedef dizin (download için)')
+    
+    # Akıllı arama komutları
+    search_parser = subparsers.add_parser('search', help='Akıllı arama')
+    search_parser.add_argument('query', nargs='?', help='Arama sorgusu')
+    search_parser.add_argument('--suggestions', action='store_true', help='Arama önerileri')
+    search_parser.add_argument('--analytics', action='store_true', help='Arama analitikleri')
+    search_parser.add_argument('--clear-history', action='store_true', help='Arama geçmişini temizle')
+    search_parser.add_argument('--language', help='Dil filtresi')
+    search_parser.add_argument('--category', help='Kategori filtresi')
+    search_parser.add_argument('--sort', choices=['relevance', 'name', 'version', 'language'], default='relevance', help='Sıralama')
+    
     # dependency komutu (yeni)
     dependency_parser = subparsers.add_parser('dependency', help='Bağımlılık yönetimi')
     dependency_subparsers = dependency_parser.add_subparsers(dest='dependency_command', help='Bağımlılık alt komutları')
@@ -341,6 +375,155 @@ def main():
             else:
                 print("❌ Geçersiz dependency komutu")
                 sys.exit(1)
+        
+        elif args.command == 'security':
+            if args.action == 'sign':
+                success, message = sign_package_file(args.package_path)
+                if success:
+                    print(f"✅ {message}")
+                else:
+                    print(f"❌ {message}")
+                    sys.exit(1)
+            
+            elif args.action == 'verify':
+                signature_path = args.signature or args.package_path.replace('.zip', '.sig')
+                success, message = verify_package_file(args.package_path, signature_path)
+                print(f"{'✅' if success else '❌'} {message}")
+                sys.exit(0 if success else 1)
+            
+            elif args.action == 'check':
+                results = check_package_security(args.package_path)
+                print("🔒 Paket Güvenlik Kontrolü")
+                print("=" * 40)
+                print(f"Bütünlük: {'✅' if results['integrity'] else '❌'}")
+                print(f"İmza: {'✅' if results['signature'] else '❌'}")
+                print(f"Checksum: {results['checksum']}")
+                if results['warnings']:
+                    print("\n⚠️  Uyarılar:")
+                    for warning in results['warnings']:
+                        print(f"  - {warning}")
+        
+        elif args.command == 'update':
+            if args.action == 'check':
+                if not args.app:
+                    print("❌ --app parametresi gerekli")
+                    sys.exit(1)
+                
+                from package_registry import get_manifest
+                manifest = get_manifest(args.app)
+                if not manifest:
+                    print(f"❌ {args.app} uygulaması bulunamadı")
+                    sys.exit(1)
+                
+                current_version = manifest.get('version', '0.0.0')
+                update_info = check_app_updates(args.app, current_version)
+                
+                print(f"📦 {args.app} Güncelleme Kontrolü")
+                print("=" * 40)
+                print(f"Mevcut: {update_info['current_version']}")
+                print(f"En son: {update_info['latest_version'] or 'Bilinmiyor'}")
+                print(f"Durum: {update_info['message']}")
+                
+                if update_info['has_update']:
+                    print(f"Güncelleme tipi: {update_info['update_type']}")
+            
+            elif args.action == 'increment':
+                if not args.app:
+                    print("❌ --app parametresi gerekli")
+                    sys.exit(1)
+                
+                from package_registry import get_manifest
+                manifest = get_manifest(args.app)
+                if not manifest:
+                    print(f"❌ {args.app} uygulaması bulunamadı")
+                    sys.exit(1)
+                
+                current_version = manifest.get('version', '0.0.0')
+                new_version = increment_app_version(current_version, args.type)
+                print(f"📦 {args.app} versiyonu artırıldı")
+                print(f"Eski: {current_version} → Yeni: {new_version}")
+        
+        elif args.command == 'cache':
+            if args.action == 'stats':
+                stats = get_cache_stats()
+                print("📊 Cache İstatistikleri")
+                print("=" * 30)
+                print(f"Hit: {stats['hits']}")
+                print(f"Miss: {stats['misses']}")
+                print(f"Hit Rate: {stats['hit_rate']}%")
+                print(f"Boyut: {stats['size_mb']} MB")
+            
+            elif args.action == 'clear':
+                deleted_count = clear_all_caches()
+                print(f"✅ {deleted_count} cache dosyası silindi")
+            
+            elif args.action == 'download':
+                if not args.urls or not args.dest:
+                    print("❌ --urls ve --dest parametreleri gerekli")
+                    sys.exit(1)
+                
+                os.makedirs(args.dest, exist_ok=True)
+                results = download_packages_parallel(args.urls, args.dest)
+                
+                print("📥 Paralel İndirme Sonuçları")
+                print("=" * 40)
+                for success, message in results:
+                    print(f"{'✅' if success else '❌'} {message}")
+        
+        elif args.command == 'search':
+            if args.suggestions:
+                from package_registry import list_packages
+                packages = list_packages()
+                suggestions = get_search_suggestions(args.query or "", packages)
+                print("💡 Arama Önerileri")
+                print("=" * 20)
+                for suggestion in suggestions:
+                    print(f"  • {suggestion}")
+            
+            elif args.analytics:
+                analytics = get_search_analytics()
+                print("📈 Arama Analitikleri")
+                print("=" * 25)
+                print(f"Toplam arama: {analytics['total_searches']}")
+                print(f"Benzersiz sorgu: {analytics['unique_queries']}")
+                print(f"Hit rate: {round(analytics['total_searches'] / max(1, analytics['unique_queries']) * 100, 1)}%")
+                
+                if analytics['most_popular']:
+                    print("\n🔥 Popüler Aramalar:")
+                    for query, count in analytics['most_popular']:
+                        print(f"  • {query} ({count} kez)")
+            
+            elif args.clear_history:
+                clear_search_history()
+            
+            elif args.query:
+                from package_registry import list_packages
+                packages = list_packages()
+                
+                filters = {}
+                if args.language:
+                    filters['language'] = args.language
+                if args.category:
+                    filters['category'] = args.category
+                if args.sort:
+                    filters['sort_by'] = args.sort
+                
+                results = search_packages(args.query, packages, filters)
+                
+                print(f"🔍 '{args.query}' için {len(results)} sonuç bulundu")
+                print("=" * 50)
+                
+                for package in results:
+                    score = package.get('search_score', 0)
+                    print(f"📦 {package['name']} v{package['version']} ({package['language']})")
+                    print(f"   {package['description']}")
+                    if score > 0:
+                        print(f"   Skor: {score:.2f}")
+                    print()
+            
+            else:
+                print("❌ Arama sorgusu gerekli veya --suggestions/--analytics kullanın")
+                sys.exit(1)
     
     except KeyboardInterrupt:
         print("\n❌ İşlem iptal edildi")