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

backup_current/package_registry.py

@@ -0,0 +1,127 @@
+import os
+import json
+from manifest_schema import validate_manifest
+
+def list_packages():
+    """
+    Yüklü paketlerin listesini döndürür.
+    
+    Returns:
+        list: Yüklü paketlerin listesi (dict formatında)
+    """
+    packages = []
+    apps_dir = "apps"
+    
+    # apps dizini yoksa oluştur
+    if not os.path.exists(apps_dir):
+        os.makedirs(apps_dir)
+        return packages
+    
+    # apps dizinindeki her klasörü kontrol et
+    for app_name in os.listdir(apps_dir):
+        app_path = os.path.join(apps_dir, app_name)
+        
+        # Sadece dizinleri kontrol et
+        if os.path.isdir(app_path):
+            manifest_path = os.path.join(app_path, "manifest.json")
+            
+            # Manifest dosyası varsa
+            if os.path.exists(manifest_path):
+                try:
+                    with open(manifest_path, 'r', encoding='utf-8') as f:
+                        manifest = json.load(f)
+                    
+                    # Manifest geçerliyse listeye ekle
+                    if validate_manifest(manifest):
+                        packages.append({
+                            'name': manifest['name'],
+                            'version': manifest.get('version', '0.0.0'),
+                            'language': manifest.get('language', 'unknown'),
+                            'description': manifest.get('description', 'Açıklama yok'),
+                            'entry': manifest.get('entry', 'main.py'),
+                            'dependencies': manifest.get('dependencies', [])
+                        })
+                except (json.JSONDecodeError, KeyError):
+                    # Geçersiz manifest dosyası, atla
+                    continue
+    
+    return packages
+
+def get_manifest(app_name):
+    """
+    Belirtilen uygulamanın manifest bilgilerini döndürür.
+    
+    Args:
+        app_name (str): Uygulama adı
+        
+    Returns:
+        dict or None: Manifest bilgileri veya None (bulunamazsa)
+    """
+    app_path = os.path.join("apps", app_name)
+    manifest_path = os.path.join(app_path, "manifest.json")
+    
+    if not os.path.exists(manifest_path):
+        return None
+    
+    try:
+        with open(manifest_path, 'r', encoding='utf-8') as f:
+            manifest = json.load(f)
+        
+        # Manifest geçerliyse döndür
+        if validate_manifest(manifest):
+            return manifest
+        else:
+            return None
+            
+    except (json.JSONDecodeError, FileNotFoundError):
+        return None
+
+def app_exists(app_name):
+    """
+    Belirtilen uygulamanın yüklü olup olmadığını kontrol eder.
+    
+    Args:
+        app_name (str): Uygulama adı
+        
+    Returns:
+        bool: Uygulama yüklüyse True, değilse False
+    """
+    return get_manifest(app_name) is not None
+
+def list_app_names():
+    """
+    Yüklü uygulamaların sadece isimlerini döndürür.
+    
+    Returns:
+        list: Uygulama isimlerinin listesi (string formatında)
+    """
+    app_names = []
+    apps_dir = "apps"
+    
+    # apps dizini yoksa oluştur
+    if not os.path.exists(apps_dir):
+        os.makedirs(apps_dir)
+        return app_names
+    
+    # apps dizinindeki her klasörü kontrol et
+    for app_name in os.listdir(apps_dir):
+        app_path = os.path.join(apps_dir, app_name)
+        
+        # Sadece dizinleri kontrol et
+        if os.path.isdir(app_path):
+            manifest_path = os.path.join(app_path, "manifest.json")
+            
+            # Manifest dosyası varsa
+            if os.path.exists(manifest_path):
+                try:
+                    with open(manifest_path, 'r', encoding='utf-8') as f:
+                        manifest = json.load(f)
+                    
+                    # Manifest geçerliyse listeye ekle
+                    if validate_manifest(manifest):
+                        app_names.append(app_name)
+                except (json.JSONDecodeError, KeyError):
+                    # Geçersiz manifest dosyası, atla
+                    continue
+    
+    return app_names 

backup_current/package_runner.py

@@ -0,0 +1,85 @@
+import os
+import json
+import subprocess
+from package_registry import get_manifest
+
+def run_app(app_name):
+    """
+    Belirtilen uygulamayı çalıştırır.
+    
+    Args:
+        app_name (str): Çalıştırılacak uygulamanın adı
+        
+    Returns:
+        bool: Uygulama başarıyla çalıştırıldıysa True, değilse False
+    """
+    # Manifest bilgilerini al
+    manifest = get_manifest(app_name)
+    
+    if not manifest:
+        print(f"Hata: '{app_name}' uygulaması bulunamadı veya geçersiz manifest dosyası.")
+        return False
+    
+    # Uygulama dizini ve giriş dosyası
+    app_path = os.path.join("apps", app_name)
+    entry_file = manifest['entry']
+    entry_path = os.path.join(app_path, entry_file)
+    
+    # Giriş dosyasının varlığını kontrol et
+    if not os.path.exists(entry_path):
+        print(f"Hata: Giriş dosyası '{entry_file}' bulunamadı.")
+        return False
+    
+    # Dile göre çalıştır
+    language = manifest['language'].lower()
+    
+    try:
+        if language == 'python':
+            # Python uygulamasını çalıştır
+            result = subprocess.run(['python', entry_file], 
+                                  cwd=app_path, 
+                                  capture_output=False)
+            return result.returncode == 0
+            
+        elif language == 'lua':
+            # Lua uygulamasını çalıştır
+            result = subprocess.run(['lua', entry_file], 
+                                  cwd=app_path, 
+                                  capture_output=False)
+            return result.returncode == 0
+            
+        else:
+            print(f"Hata: Desteklenmeyen dil '{language}'. Desteklenen diller: python, lua")
+            return False
+            
+    except FileNotFoundError as e:
+        if language == 'python':
+            print("Hata: Python yüklü değil veya PATH'te bulunamadı.")
+        elif language == 'lua':
+            print("Hata: Lua yüklü değil veya PATH'te bulunamadı.")
+        return False
+        
+    except Exception as e:
+        print(f"Hata: Uygulama çalıştırılırken bir hata oluştu: {e}")
+        return False
+
+def get_supported_languages():
+    """
+    Desteklenen programlama dillerinin listesini döndürür.
+    
+    Returns:
+        list: Desteklenen diller listesi
+    """
+    return ['python', 'lua']
+
+def check_language_support(language):
+    """
+    Belirtilen dilin desteklenip desteklenmediğini kontrol eder.
+    
+    Args:
+        language (str): Kontrol edilecek dil
+        
+    Returns:
+        bool: Dil destekleniyorsa True, değilse False
+    """
+    return language.lower() in get_supported_languages() 

backup_current/post_install_hint.py

@@ -0,0 +1,144 @@
+#!/usr/bin/env python3
+"""
+post_install_hint.py - Kurulum sonrası yardım ipuçları
+
+Bu modül kullanıcıya clapp kurulumu sonrasında PATH ve ortam
+sorunları hakkında bilgi verir.
+"""
+
+import os
+import sys
+import shutil
+import platform
+from pathlib import Path
+
+def get_platform_type():
+    """Platform türünü döndürür"""
+    system = platform.system().lower()
+    if system == "windows":
+        return "windows"
+    elif system == "darwin":
+        return "macos"
+    else:
+        return "linux"
+
+def get_onboarded_flag_path():
+    """Onboarding flag dosyasının yolunu döndürür"""
+    home = Path.home()
+    clapp_dir = home / ".clapp"
+    return clapp_dir / ".onboarded"
+
+def is_onboarded():
+    """Kullanıcının daha önce onboarding gördüğünü kontrol eder"""
+    return get_onboarded_flag_path().exists()
+
+def mark_as_onboarded():
+    """Kullanıcıyı onboarded olarak işaretler"""
+    flag_path = get_onboarded_flag_path()
+    flag_path.parent.mkdir(exist_ok=True)
+    flag_path.write_text("onboarded")
+
+def get_path_suggestions():
+    """Platform'a göre PATH önerilerini döndürür"""
+    platform_type = get_platform_type()
+    
+    if platform_type == "windows":
+        return [
+            "Windows PATH'e eklemek için:",
+            "1. Sistem Özellikleri > Gelişmiş > Ortam Değişkenleri",
+            "2. PATH değişkenine Python Scripts klasörünü ekleyin",
+            "3. Örnek: C:\\Python39\\Scripts",
+            "",
+            "Veya PowerShell'de:",
+            '$env:PATH += ";C:\\Python39\\Scripts"'
+        ]
+    elif platform_type == "macos":
+        return [
+            "macOS PATH'e eklemek için:",
+            "~/.zshrc veya ~/.bash_profile dosyasına ekleyin:",
+            'export PATH="$PATH:$HOME/.local/bin"',
+            "",
+            "Sonra terminali yeniden başlatın veya:",
+            "source ~/.zshrc"
+        ]
+    else:  # linux
+        return [
+            "Linux PATH'e eklemek için:",
+            "~/.bashrc veya ~/.profile dosyasına ekleyin:",
+            'export PATH="$PATH:$HOME/.local/bin"',
+            "",
+            "Sonra terminali yeniden başlatın veya:",
+            "source ~/.bashrc"
+        ]
+
+def show_post_install_hint():
+    """Kurulum sonrası ipuçlarını gösterir"""
+    # Eğer zaten onboarded ise gösterme
+    if is_onboarded():
+        return
+    
+    # clapp PATH'te var mı kontrol et
+    clapp_in_path = shutil.which("clapp") is not None
+    
+    if not clapp_in_path:
+        print("🚀 clapp'e Hoş Geldiniz!")
+        print("=" * 50)
+        print("⚠️  clapp komutu sistem PATH'inde bulunamadı.")
+        print("Bu, 'clapp' komutunu her yerden çalıştıramamanız anlamına gelir.")
+        print()
+        
+        # Platform'a göre öneriler
+        suggestions = get_path_suggestions()
+        for suggestion in suggestions:
+            print(suggestion)
+        
+        print()
+        print("🔧 Alternatif olarak:")
+        print("• Python -m clapp [komut] şeklinde çalıştırabilirsiniz")
+        print("• Veya python main.py [komut] şeklinde çalıştırabilirsiniz")
+        print()
+        print("📋 Sistem kontrolü için: clapp check-env")
+        print("🩺 Detaylı tanılama için: clapp doctor")
+        print()
+        print("Bu mesajı bir daha görmek istemiyorsanız:")
+        print("clapp doctor komutunu çalıştırın ve sorunları düzeltin.")
+        print("=" * 50)
+    else:
+        print("✅ clapp başarıyla kuruldu ve PATH'te mevcut!")
+        print("🎉 Başlamak için: clapp list")
+        
+        # Onboarded olarak işaretle
+        mark_as_onboarded()
+
+def show_welcome_message():
+    """Hoş geldin mesajını gösterir"""
+    print("🎉 clapp - Hafif Çoklu Dil Uygulama Yöneticisi")
+    print()
+    print("📚 Temel komutlar:")
+    print("  clapp list              - Yüklü uygulamaları listele")
+    print("  clapp run <app>         - Uygulama çalıştır")
+    print("  clapp info <app>        - Uygulama bilgilerini göster")
+    print("  clapp gui               - Grafik arayüzü başlat")
+    print("  clapp check-env         - Sistem kontrolü")
+    print("  clapp doctor            - Detaylı tanılama")
+    print()
+    print("🔧 Yönetim komutları:")
+    print("  clapp install <source>  - Uygulama yükle")
+    print("  clapp uninstall <app>   - Uygulama kaldır")
+    print("  clapp upgrade <app>     - Uygulama güncelle")
+    print("  clapp validate <folder> - Uygulama klasörünü doğrula")
+    print("  clapp clean             - Geçici dosyaları temizle")
+    print()
+    print("📖 Daha fazla yardım için: clapp --help")
+
+def check_first_run():
+    """İlk çalıştırma kontrolü yapar"""
+    if not is_onboarded():
+        show_welcome_message()
+        print()
+        show_post_install_hint()
+        return True
+    return False
+
+if __name__ == "__main__":
+    show_post_install_hint() 

backup_current/publish_command.py

@@ -0,0 +1,253 @@
+#!/usr/bin/env python3
+"""
+publish_command.py - clapp Publish Command
+
+Bu modül 'clapp publish <folder>' komutunu uygular.
+Bir uygulama klasörünü validate edip packages/ klasörüne kopyalar
+ve index.json'u günceller. Opsiyonel olarak clapp-packages reposuna push eder.
+"""
+
+import os
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+from typing import Tuple, Optional
+
+from manifest_validator import validate_manifest_verbose
+from manifest_schema import load_manifest
+
+def validate_app_folder(folder_path: str) -> Tuple[bool, str, Optional[dict]]:
+    """
+    Uygulama klasörünü doğrular
+    
+    Returns:
+        (success, message, manifest_data)
+    """
+    if not os.path.exists(folder_path):
+        return False, f"Klasör bulunamadı: {folder_path}", None
+    
+    if not os.path.isdir(folder_path):
+        return False, f"Geçerli bir klasör değil: {folder_path}", None
+    
+    # manifest.json kontrolü
+    manifest_path = os.path.join(folder_path, "manifest.json")
+    if not os.path.exists(manifest_path):
+        return False, "manifest.json dosyası bulunamadı", None
+    
+    try:
+        manifest = load_manifest(manifest_path)
+    except Exception as e:
+        return False, f"manifest.json okunamadı: {e}", None
+    
+    # Manifest doğrulama
+    is_valid, errors = validate_manifest_verbose(manifest)
+    if not is_valid:
+        error_msg = "Manifest doğrulama hatası:\n" + "\n".join(f"  - {error}" for error in errors)
+        return False, error_msg, None
+    
+    # Entry file kontrolü
+    entry_file = manifest.get('entry')
+    if entry_file:
+        entry_path = os.path.join(folder_path, entry_file)
+        if not os.path.exists(entry_path):
+            return False, f"Entry dosyası bulunamadı: {entry_file}", None
+    
+    return True, "Doğrulama başarılı", manifest
+
+def copy_app_to_packages(source_folder: str, app_name: str) -> Tuple[bool, str]:
+    """
+    Uygulama klasörünü packages/ altına kopyalar
+    
+    Returns:
+        (success, message)
+    """
+    try:
+        packages_dir = "./packages"
+        target_path = os.path.join(packages_dir, app_name)
+        
+        # packages klasörünü oluştur
+        os.makedirs(packages_dir, exist_ok=True)
+        
+        # Eğer hedef klasör varsa, sil
+        if os.path.exists(target_path):
+            shutil.rmtree(target_path)
+            print(f"⚠️  Mevcut {app_name} klasörü silindi")
+        
+        # Kopyala
+        shutil.copytree(source_folder, target_path)
+        print(f"✅ {app_name} -> packages/{app_name} kopyalandı")
+        
+        return True, f"Uygulama başarıyla kopyalandı: packages/{app_name}"
+        
+    except Exception as e:
+        return False, f"Kopyalama hatası: {e}"
+
+def update_index() -> Tuple[bool, str]:
+    """
+    build_index.py script'ini çalıştırarak index.json'u günceller
+    
+    Returns:
+        (success, message)
+    """
+    try:
+        # build_index.py'yi çalıştır
+        result = subprocess.run([
+            sys.executable, "build_index.py"
+        ], capture_output=True, text=True, cwd=".")
+        
+        if result.returncode == 0:
+            return True, "Index başarıyla güncellendi"
+        else:
+            return False, f"Index güncelleme hatası: {result.stderr}"
+            
+    except Exception as e:
+        return False, f"Index script çalıştırılamadı: {e}"
+
+def push_to_clapp_packages_repo(app_name: str, app_version: str) -> Tuple[bool, str]:
+    """
+    Değişiklikleri clapp-packages reposuna push eder
+    
+    Returns:
+        (success, message)
+    """
+    try:
+        print("4️⃣ clapp-packages reposuna push ediliyor...")
+        
+        # clapp-packages reposunu kontrol et
+        packages_repo_path = "./clapp-packages-repo"
+        
+        # Eğer clapp-packages repo klonlanmamışsa, klonla
+        if not os.path.exists(packages_repo_path):
+            print("📥 clapp-packages reposu klonlanıyor...")
+            subprocess.run([
+                'git', 'clone', 'https://github.com/mburakmmm/clapp-packages.git', 
+                packages_repo_path
+            ], check=True, cwd=".")
+        
+        # packages/ klasörünü clapp-packages reposuna kopyala
+        source_packages = "./packages"
+        target_packages = os.path.join(packages_repo_path, "packages")
+        
+        if os.path.exists(target_packages):
+            shutil.rmtree(target_packages)
+        
+        shutil.copytree(source_packages, target_packages)
+        print(f"✅ packages/ klasörü clapp-packages reposuna kopyalandı")
+        
+        # index.json'u da kopyala
+        if os.path.exists("index.json"):
+            shutil.copy("index.json", os.path.join(packages_repo_path, "index.json"))
+            print("✅ index.json clapp-packages reposuna kopyalandı")
+        
+        # clapp-packages reposuna git işlemleri
+        os.chdir(packages_repo_path)
+        
+        # Git durumunu kontrol et
+        result = subprocess.run(['git', 'status', '--porcelain'], 
+                              capture_output=True, text=True)
+        
+        if not result.stdout.strip():
+            os.chdir("..")
+            return True, "Değişiklik yok, push gerekmiyor"
+        
+        # Değişiklikleri ekle
+        subprocess.run(['git', 'add', '.'], check=True)
+        
+        # Commit oluştur
+        commit_message = f"📦 Publish {app_name} v{app_version}\n\n- {app_name} uygulaması packages/ klasörüne eklendi\n- index.json güncellendi\n- Otomatik publish işlemi"
+        
+        subprocess.run(['git', 'commit', '-m', commit_message], check=True)
+        
+        # Push et
+        subprocess.run(['git', 'push', 'origin', 'main'], check=True)
+        
+        # Ana dizine geri dön
+        os.chdir("..")
+        
+        return True, "clapp-packages reposuna başarıyla push edildi"
+        
+    except subprocess.CalledProcessError as e:
+        # Ana dizine geri dön
+        if os.getcwd() != os.path.abspath("."):
+            os.chdir("..")
+        return False, f"Git işlemi hatası: {e}"
+    except Exception as e:
+        # Ana dizine geri dön
+        if os.getcwd() != os.path.abspath("."):
+            os.chdir("..")
+        return False, f"Push hatası: {e}"
+
+def publish_app(folder_path: str, force: bool = False, push_to_github: bool = False) -> Tuple[bool, str]:
+    """
+    Ana publish fonksiyonu
+    
+    Args:
+        folder_path: Publish edilecek uygulama klasörü
+        force: Zorla üzerine yaz
+        push_to_github: clapp-packages reposuna push et
+        
+    Returns:
+        (success, message)
+    """
+    print(f"🚀 Publish başlatılıyor: {folder_path}")
+    print("=" * 50)
+    
+    # 1. Klasörü doğrula
+    print("1️⃣ Uygulama doğrulanıyor...")
+    is_valid, message, manifest = validate_app_folder(folder_path)
+    
+    if not is_valid:
+        return False, f"Doğrulama hatası: {message}"
+    
+    app_name = manifest['name']
+    app_version = manifest['version']
+    print(f"✅ {app_name} v{app_version} doğrulandı")
+    
+    # 2. Packages klasörüne kopyala
+    print("2️⃣ Uygulama kopyalanıyor...")
+    copy_success, copy_message = copy_app_to_packages(folder_path, app_name)
+    
+    if not copy_success:
+        return False, copy_message
+    
+    # 3. Index'i güncelle
+    print("3️⃣ Index güncelleniyor...")
+    index_success, index_message = update_index()
+    
+    if not index_success:
+        return False, index_message
+    
+    # 4. clapp-packages reposuna push (opsiyonel)
+    if push_to_github:
+        push_success, push_message = push_to_clapp_packages_repo(app_name, app_version)
+        if not push_success:
+            print(f"⚠️  {push_message}")
+            return True, f"🎉 '{app_name}' yerel olarak publish edildi! clapp-packages push başarısız."
+    
+    return True, f"🎉 '{app_name}' başarıyla publish edildi! Index güncellendi."
+
+def main():
+    """CLI entry point"""
+    if len(sys.argv) < 2:
+        print("Kullanım: python publish_command.py <folder_path> [--push]")
+        print("Örnek: python publish_command.py ./my-app")
+        print("Örnek: python publish_command.py ./my-app --push")
+        sys.exit(1)
+    
+    folder_path = sys.argv[1]
+    force = "--force" in sys.argv
+    push_to_github = "--push" in sys.argv
+    
+    success, message = publish_app(folder_path, force, push_to_github)
+    
+    print("\n" + "=" * 50)
+    if success:
+        print(f"✅ {message}")
+        sys.exit(0)
+    else:
+        print(f"❌ {message}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()