clapp-pm 1.0.10__py3-none-any.whl → 1.0.13__py3-none-any.whl

backup_current/doctor_command.py

@@ -0,0 +1,239 @@
+#!/usr/bin/env python3
+"""
+doctor_command.py - Kapsamlı sistem tanılaması modülü
+
+Bu modül `clapp doctor` komutunu destekler ve sistemin
+clapp için uygun olup olmadığını kapsamlı şekilde kontrol eder.
+"""
+
+import os
+import sys
+import shutil
+import platform
+import subprocess
+from pathlib import Path
+from check_env import (
+    check_python_version,
+    check_clapp_in_path,
+    check_platform_info,
+    check_python_executable,
+    check_working_directory,
+    check_apps_directory,
+    check_permissions,
+)
+
+def check_clapp_config():
+    """clapp konfigürasyon dizinini kontrol eder"""
+    home = Path.home()
+    clapp_config_dir = home / ".clapp"
+    
+    if clapp_config_dir.exists():
+        return True, f"Konfigürasyon dizini mevcut: {clapp_config_dir}"
+    else:
+        return False, "Konfigürasyon dizini bulunamadı (~/.clapp)"
+
+def check_path_environment():
+    """PATH ortam değişkenini detaylı kontrol eder"""
+    path_env = os.environ.get("PATH", "")
+    path_dirs = path_env.split(os.pathsep)
+    
+    # Önemli dizinleri kontrol et
+    important_dirs = []
+    
+    # Platform'a göre önemli dizinler
+    system = platform.system().lower()
+    if system == "windows":
+        important_dirs = [
+            os.path.join(os.environ.get("APPDATA", ""), "Python", "Scripts"),
+            os.path.join(sys.prefix, "Scripts"),
+        ]
+    else:
+        home = Path.home()
+        important_dirs = [
+            str(home / ".local" / "bin"),
+            "/usr/local/bin",
+            "/usr/bin",
+        ]
+    
+    found_dirs = []
+    missing_dirs = []
+    
+    for imp_dir in important_dirs:
+        if imp_dir in path_dirs:
+            found_dirs.append(imp_dir)
+        else:
+            missing_dirs.append(imp_dir)
+    
+    if missing_dirs:
+        return False, f"PATH'te eksik dizinler: {', '.join(missing_dirs)}"
+    else:
+        return True, f"PATH uygun ({len(found_dirs)} önemli dizin mevcut)"
+
+def check_dependencies():
+    """Bağımlılıkları kontrol eder"""
+    dependencies = ["python", "pip"]
+    
+    missing = []
+    found = []
+    
+    for dep in dependencies:
+        if shutil.which(dep):
+            found.append(dep)
+        else:
+            missing.append(dep)
+    
+    if missing:
+        return False, f"Eksik bağımlılıklar: {', '.join(missing)}"
+    else:
+        return True, f"Tüm bağımlılıklar mevcut: {', '.join(found)}"
+
+def check_disk_space():
+    """Disk alanını kontrol eder"""
+    try:
+        cwd = Path.cwd()
+        stat = shutil.disk_usage(cwd)
+        
+        # GB'ye çevir
+        free_gb = stat.free / (1024**3)
+        total_gb = stat.total / (1024**3)
+        
+        if free_gb < 0.5:  # 500MB'den az
+            return False, f"Yetersiz disk alanı: {free_gb:.1f}GB boş"
+        else:
+            return True, f"Disk alanı uygun: {free_gb:.1f}GB / {total_gb:.1f}GB"
+    
+    except Exception as e:
+        return False, f"Disk alanı kontrol edilemedi: {str(e)}"
+
+def check_network_access():
+    """Ağ erişimini kontrol eder"""
+    try:
+        # Basit bir ping testi
+        import socket
+        socket.create_connection(("8.8.8.8", 53), timeout=3)
+        return True, "Ağ erişimi mevcut"
+    except:
+        return False, "Ağ erişimi yok veya sınırlı"
+
+def check_installed_apps():
+    """Yüklü uygulamaları kontrol eder"""
+    try:
+        from package_registry import list_packages
+        packages = list_packages()
+        
+        if not packages:
+            return True, "Yüklü uygulama yok (normal)"
+        
+        # Bozuk uygulamaları kontrol et
+        broken_apps = []
+        for package in packages:
+            if not package.get("name") or not package.get("entry"):
+                broken_apps.append(package.get("name", "Bilinmiyor"))
+        
+        if broken_apps:
+            return False, f"Bozuk uygulamalar: {', '.join(broken_apps)}"
+        else:
+            return True, f"{len(packages)} uygulama yüklü (tümü geçerli)"
+    
+    except Exception as e:
+        return False, f"Uygulama listesi kontrol edilemedi: {str(e)}"
+
+def check_python_modules():
+    """Gerekli Python modüllerini kontrol eder"""
+    required_modules = [
+        ("json", "JSON desteği"),
+        ("os", "İşletim sistemi arayüzü"),
+        ("sys", "Sistem arayüzü"),
+        ("pathlib", "Dosya yolu işlemleri"),
+        ("subprocess", "Alt süreç yönetimi"),
+        ("argparse", "Komut satırı ayrıştırma"),
+    ]
+    
+    missing = []
+    found = []
+    
+    for module_name, description in required_modules:
+        try:
+            __import__(module_name)
+            found.append(module_name)
+        except ImportError:
+            missing.append(f"{module_name} ({description})")
+    
+    if missing:
+        return False, f"Eksik Python modülleri: {', '.join(missing)}"
+    else:
+        return True, f"Tüm gerekli modüller mevcut ({len(found)} modül)"
+
+def check_apps_directory():
+    """apps/ dizinini kontrol eder, yoksa otomatik oluşturur veya bilgi verir"""
+    apps_dir = Path("apps")
+    if apps_dir.exists():
+        return True, "apps/ dizini mevcut"
+    else:
+        try:
+            apps_dir.mkdir(parents=True, exist_ok=True)
+            return True, "apps/ dizini yoktu, otomatik oluşturuldu (ilk kurulum için normal)"
+        except Exception as e:
+            return False, f"apps/ dizini oluşturulamadı: {e}"
+
+
+def run_doctor():
+    """Kapsamlı sistem tanılaması yapar"""
+    print("🩺 clapp Sistem Tanılaması")
+    print("=" * 60)
+    print("Sisteminiz clapp için uygun mu kontrol ediliyor...")
+    print()
+    # Tüm kontroller
+    checks = [
+        ("Python Sürümü", check_python_version),
+        ("Platform Bilgisi", check_platform_info),
+        ("Python Çalıştırılabilir", check_python_executable),
+        ("Çalışma Dizini", check_working_directory),
+        ("clapp PATH Kontrolü", check_clapp_in_path),
+        ("PATH Ortam Değişkeni", check_path_environment),
+        ("Sistem Bağımlılıkları", check_dependencies),
+        ("Python Modülleri", check_python_modules),
+        ("apps/ Dizini", check_apps_directory),
+        ("Yüklü Uygulamalar", check_installed_apps),
+        ("Yazma İzinleri", check_permissions),
+        ("Disk Alanı", check_disk_space),
+        ("Ağ Erişimi", check_network_access),
+        ("clapp Konfigürasyonu", check_clapp_config),
+    ]
+    passed = 0
+    failed = 0
+    warnings = 0
+    results = []
+    for check_name, check_func in checks:
+        try:
+            ok, msg = check_func()
+            if ok:
+                print(f"✅ {check_name}: {msg}")
+                passed += 1
+            else:
+                print(f"❌ {check_name}: {msg}")
+                failed += 1
+            results.append((check_name, ok, msg))
+        except Exception as e:
+            print(f"❌ {check_name}: Kontrol sırasında hata: {e}")
+            failed += 1
+            results.append((check_name, False, str(e)))
+    print("\n" + "=" * 60)
+    print(f"📊 Tanılama Özeti:")
+    print(f"✅ Başarılı: {passed}")
+    print(f"❌ Başarısız: {failed}")
+    print(f"⚠️  Uyarı: {warnings}")
+    if failed > 0:
+        print("\n🔧 Dikkat! Bazı sorunlar bulundu.")
+        print("❌ Aşağıdaki sorunları çözmeniz önerilir:")
+        for name, ok, msg in results:
+            if not ok:
+                print(f"\n🔧 {name}:\n   Sorun: {msg}")
+    else:
+        print("\n🚀 Her şey yolunda! clapp sorunsuz çalışabilir.")
+    print("\n📞 Yardım:")
+    print("• GitHub: https://github.com/user/clapp")
+    print("• Dokümantasyon: README.md dosyasını okuyun")
+
+if __name__ == "__main__":
+    run_doctor() 

backup_current/info_command.py

@@ -0,0 +1,194 @@
+#!/usr/bin/env python3
+"""
+info_command.py - Uygulama bilgi görüntüleme modülü
+
+Bu modül `clapp info <app_name>` komutunu destekler ve
+yüklü uygulamaların detaylı bilgilerini gösterir.
+"""
+
+import os
+import json
+from pathlib import Path
+from package_registry import get_manifest
+
+def format_field(name, value, width=20):
+    """Alanı formatlar"""
+    if value is None or value == "":
+        value = "Belirtilmemiş"
+    return f"{name:<{width}}: {value}"
+
+def format_list(items, indent=22):
+    """Liste öğelerini formatlar"""
+    if not items:
+        return "Yok"
+    
+    if len(items) == 1:
+        return items[0]
+    
+    result = items[0]
+    for item in items[1:]:
+        result += f"\n{' ' * indent}{item}"
+    return result
+
+def get_app_file_info(app_name):
+    """Uygulama dosya bilgilerini toplar"""
+    apps_dir = Path("apps")
+    app_dir = apps_dir / app_name
+    
+    if not app_dir.exists():
+        return None
+    
+    info = {
+        "path": str(app_dir.absolute()),
+        "size": 0,
+        "file_count": 0,
+        "files": []
+    }
+    
+    try:
+        for file_path in app_dir.rglob("*"):
+            if file_path.is_file():
+                info["file_count"] += 1
+                info["size"] += file_path.stat().st_size
+                info["files"].append(file_path.name)
+    except Exception:
+        pass
+    
+    return info
+
+def format_size(size_bytes):
+    """Dosya boyutunu formatlar"""
+    if size_bytes == 0:
+        return "0 B"
+    
+    for unit in ['B', 'KB', 'MB', 'GB']:
+        if size_bytes < 1024.0:
+            return f"{size_bytes:.1f} {unit}"
+        size_bytes /= 1024.0
+    
+    return f"{size_bytes:.1f} TB"
+
+def show_app_info(app_name):
+    """Uygulama bilgilerini gösterir"""
+    print(f"📋 {app_name} - Uygulama Bilgileri")
+    print("=" * 50)
+    
+    # Manifest bilgilerini al
+    manifest = get_manifest(app_name)
+    
+    if not manifest:
+        print(f"❌ '{app_name}' uygulaması bulunamadı veya manifest.json eksik.")
+        print()
+        print("🔧 Öneriler:")
+        print("• Uygulama adını kontrol edin")
+        print("• apps/ dizininde uygulama klasörünün var olduğundan emin olun")
+        print("• manifest.json dosyasının mevcut olduğundan emin olun")
+        print("• Doğrulama için: clapp validate apps/[app_name]")
+        return False
+    
+    # Temel bilgiler
+    print("📦 Temel Bilgiler:")
+    print(format_field("Ad", manifest.get("name", app_name)))
+    print(format_field("Sürüm", manifest.get("version", "Belirtilmemiş")))
+    print(format_field("Dil", manifest.get("language", "Belirtilmemiş")))
+    print(format_field("Giriş Dosyası", manifest.get("entry", "Belirtilmemiş")))
+    print()
+    
+    # Açıklama
+    description = manifest.get("description", "")
+    if description:
+        print("📝 Açıklama:")
+        print(f"   {description}")
+        print()
+    
+    # Bağımlılıklar
+    dependencies = manifest.get("dependencies", [])
+    print("🔗 Bağımlılıklar:")
+    if dependencies:
+        for dep in dependencies:
+            print(f"   • {dep}")
+    else:
+        print("   Bağımlılık yok")
+    print()
+    
+    # Dosya bilgileri
+    file_info = get_app_file_info(app_name)
+    if file_info:
+        print("📁 Dosya Bilgileri:")
+        print(format_field("Konum", file_info["path"]))
+        print(format_field("Dosya Sayısı", file_info["file_count"]))
+        print(format_field("Toplam Boyut", format_size(file_info["size"])))
+        print()
+        
+        # Dosya listesi (ilk 10 dosya)
+        if file_info["files"]:
+            print("📄 Dosyalar:")
+            files_to_show = file_info["files"][:10]
+            for file_name in files_to_show:
+                print(f"   • {file_name}")
+            
+            if len(file_info["files"]) > 10:
+                print(f"   ... ve {len(file_info['files']) - 10} dosya daha")
+            print()
+    
+    # Ek bilgiler
+    extra_fields = ["author", "license", "homepage", "repository"]
+    extra_info = []
+    
+    for field in extra_fields:
+        if field in manifest:
+            extra_info.append((field.title(), manifest[field]))
+    
+    if extra_info:
+        print("ℹ️  Ek Bilgiler:")
+        for field_name, value in extra_info:
+            print(format_field(field_name, value))
+        print()
+    
+    # Çalıştırma bilgisi
+    print("🚀 Çalıştırma:")
+    print(f"   clapp run {app_name}")
+    
+    # Doğrulama önerisi
+    print()
+    print("🔧 Doğrulama:")
+    print(f"   clapp validate apps/{app_name}")
+    
+    return True
+
+def list_all_apps_info():
+    """Tüm uygulamaların kısa bilgilerini listeler"""
+    from package_registry import list_packages
+    
+    packages = list_packages()
+    
+    if not packages:
+        print("📦 Yüklü uygulama bulunamadı.")
+        return
+    
+    print("📋 Yüklü Uygulamalar - Özet Bilgiler")
+    print("=" * 60)
+    
+    for package in packages:
+        name = package.get("name", "Bilinmiyor")
+        version = package.get("version", "?")
+        language = package.get("language", "?")
+        description = package.get("description", "Açıklama yok")
+        
+        # Açıklamayı kısalt
+        if len(description) > 40:
+            description = description[:37] + "..."
+        
+        print(f"📦 {name} (v{version})")
+        print(f"   🔧 Dil: {language}")
+        print(f"   📝 {description}")
+        print()
+
+if __name__ == "__main__":
+    import sys
+    
+    if len(sys.argv) > 1:
+        app_name = sys.argv[1]
+        show_app_info(app_name)
+    else:
+        list_all_apps_info() 

backup_current/install_command.py

@@ -0,0 +1,236 @@
+#!/usr/bin/env python3
+"""
+install_command.py - clapp Install Command
+
+Bu modül 'clapp install <app_name>' komutunu uygular.
+Index.json'dan uygulama bilgilerini alıp GitHub'dan indirerek
+yerel apps/ klasörüne kurar.
+"""
+
+import os
+import json
+import shutil
+import requests
+import zipfile
+import tempfile
+import sys
+from pathlib import Path
+from typing import Tuple, Optional, Dict, Any
+
+from manifest_validator import validate_manifest_verbose
+
+def get_apps_directory() -> str:
+    """Uygulamaların kurulacağı dizini döndürür"""
+    # Kullanıcının home dizininde .clapp klasörü oluştur
+    home_dir = Path.home()
+    clapp_dir = home_dir / ".clapp"
+    apps_dir = clapp_dir / "apps"
+    
+    # Klasörleri oluştur
+    apps_dir.mkdir(parents=True, exist_ok=True)
+    
+    return str(apps_dir)
+
+def load_index(index_path: str = "index.json") -> Tuple[bool, str, Optional[list]]:
+    """
+    Index.json dosyasını yükler
+    
+    Returns:
+        (success, message, apps_list)
+    """
+    try:
+        # Yerel index.json'u kontrol et
+        if os.path.exists(index_path):
+            with open(index_path, 'r', encoding='utf-8') as f:
+                apps = json.load(f)
+            return True, "Yerel index yüklendi", apps
+        
+        # GitHub'dan index.json'u indir
+        print("🔄 GitHub'dan index.json indiriliyor...")
+        url = "https://raw.githubusercontent.com/mburakmmm/clapp-packages/main/index.json"
+        response = requests.get(url, timeout=10)
+        
+        if response.status_code == 200:
+            apps = response.json()
+            # Yerel kopyasını kaydet
+            with open(index_path, 'w', encoding='utf-8') as f:
+                json.dump(apps, f, indent=2, ensure_ascii=False)
+            return True, "GitHub'dan index indirildi", apps
+        else:
+            return False, f"GitHub'dan index indirilemedi: {response.status_code}", None
+            
+    except requests.RequestException as e:
+        return False, f"Network hatası: {e}", None
+    except json.JSONDecodeError as e:
+        return False, f"JSON parse hatası: {e}", None
+    except Exception as e:
+        return False, f"Index yükleme hatası: {e}", None
+
+def find_app_in_index(app_name: str, apps: list) -> Optional[Dict[str, Any]]:
+    """Index'te uygulama arar"""
+    for app in apps:
+        if app.get('name') == app_name:
+            return app
+    return None
+
+def download_app_from_github(app_info: Dict[str, Any], temp_dir: str) -> Tuple[bool, str]:
+    """
+    GitHub'dan uygulama dosyalarını indirir
+    
+    Returns:
+        (success, message)
+    """
+    try:
+        repo_url = app_info.get('repo_url', 'https://github.com/mburakmmm/clapp-packages')
+        subdir = app_info.get('subdir', app_info['name'])
+        
+        # GitHub zip URL'si oluştur
+        if 'github.com' in repo_url:
+            # https://github.com/user/repo -> https://github.com/user/repo/archive/refs/heads/main.zip
+            zip_url = repo_url + "/archive/refs/heads/main.zip"
+        else:
+            return False, f"Desteklenmeyen repo URL: {repo_url}"
+        
+        print(f"📥 İndiriliyor: {zip_url}")
+        
+        # Zip dosyasını indir
+        response = requests.get(zip_url, timeout=30)
+        if response.status_code != 200:
+            return False, f"İndirme hatası: {response.status_code}"
+        
+        # Zip dosyasını geçici klasöre kaydet
+        zip_path = os.path.join(temp_dir, "repo.zip")
+        with open(zip_path, 'wb') as f:
+            f.write(response.content)
+        
+        # Zip'i aç
+        with zipfile.ZipFile(zip_path, 'r') as zip_ref:
+            zip_ref.extractall(temp_dir)
+        
+        # Çıkarılan klasörü bul (genellikle repo-main formatında)
+        extracted_folders = [d for d in os.listdir(temp_dir) if os.path.isdir(os.path.join(temp_dir, d))]
+        if not extracted_folders:
+            return False, "Çıkarılan klasör bulunamadı"
+        
+        extracted_folder = extracted_folders[0]
+        app_source_path = os.path.join(temp_dir, extracted_folder, subdir)
+        
+        if not os.path.exists(app_source_path):
+            return False, f"Uygulama klasörü bulunamadı: {subdir}"
+        
+        return True, app_source_path
+        
+    except Exception as e:
+        return False, f"İndirme hatası: {e}"
+
+def install_app_locally(app_name: str, source_path: str) -> Tuple[bool, str]:
+    """
+    Uygulamayı yerel apps klasörüne kurar
+    
+    Returns:
+        (success, message)
+    """
+    try:
+        apps_dir = get_apps_directory()
+        target_path = os.path.join(apps_dir, app_name)
+        
+        # Hedef klasör varsa sil
+        if os.path.exists(target_path):
+            shutil.rmtree(target_path)
+            print(f"⚠️  Mevcut {app_name} kaldırıldı")
+        
+        # Kopyala
+        shutil.copytree(source_path, target_path)
+        
+        # Manifest'i doğrula
+        manifest_path = os.path.join(target_path, "manifest.json")
+        if os.path.exists(manifest_path):
+            with open(manifest_path, 'r', encoding='utf-8') as f:
+                manifest = json.load(f)
+            
+            is_valid, errors = validate_manifest_verbose(manifest)
+            if not is_valid:
+                shutil.rmtree(target_path)
+                return False, f"Manifest doğrulama hatası: {errors}"
+        
+        return True, f"Uygulama kuruldu: {target_path}"
+        
+    except Exception as e:
+        return False, f"Kurulum hatası: {e}"
+
+def install_app(app_name: str) -> Tuple[bool, str]:
+    """
+    Ana install fonksiyonu
+    
+    Args:
+        app_name: Kurulacak uygulamanın adı
+        
+    Returns:
+        (success, message)
+    """
+    print(f"🚀 Kurulum başlatılıyor: {app_name}")
+    print("=" * 50)
+    
+    # 1. Index'i yükle
+    print("1️⃣ Index yükleniyor...")
+    index_success, index_message, apps = load_index()
+    
+    if not index_success:
+        return False, f"Index yükleme hatası: {index_message}"
+    
+    print(f"✅ {len(apps)} uygulama listelendi")
+    
+    # 2. Uygulamayı index'te ara
+    print("2️⃣ Uygulama aranıyor...")
+    app_info = find_app_in_index(app_name, apps)
+    
+    if not app_info:
+        available_apps = [app['name'] for app in apps]
+        return False, f"Uygulama bulunamadı: {app_name}\nMevcut uygulamalar: {', '.join(available_apps)}"
+    
+    print(f"✅ {app_name} v{app_info['version']} bulundu")
+    
+    # 3. Geçici klasör oluştur
+    with tempfile.TemporaryDirectory() as temp_dir:
+        print("3️⃣ Uygulama indiriliyor...")
+        
+        # GitHub'dan indir
+        download_success, download_result = download_app_from_github(app_info, temp_dir)
+        
+        if not download_success:
+            return False, f"İndirme hatası: {download_result}"
+        
+        source_path = download_result
+        print(f"✅ İndirme tamamlandı")
+        
+        # 4. Yerel kurulum
+        print("4️⃣ Uygulama kuruluyor...")
+        install_success, install_message = install_app_locally(app_name, source_path)
+        
+        if not install_success:
+            return False, install_message
+    
+    return True, f"🎉 '{app_name}' başarıyla kuruldu!"
+
+def main():
+    """CLI entry point"""
+    if len(sys.argv) < 2:
+        print("Kullanım: python install_command.py <app_name>")
+        print("Örnek: python install_command.py hello-python")
+        sys.exit(1)
+    
+    app_name = sys.argv[1]
+    
+    success, message = install_app(app_name)
+    
+    print("\n" + "=" * 50)
+    if success:
+        print(f"✅ {message}")
+        print(f"📍 Kurulum dizini: {get_apps_directory()}")
+        sys.exit(0)
+    else:
+        print(f"❌ {message}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()