clapp-pm 1.0.0__py3-none-any.whl → 1.0.2__py3-none-any.whl

{clapp_pm-1.0.0.data → clapp_pm-1.0.2.data}/data/version.json

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

{clapp_pm-1.0.0.dist-info → clapp_pm-1.0.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clapp-pm
-Version: 1.0.0
+Version: 1.0.2
 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.0.dist-info → clapp_pm-1.0.2.dist-info}/RECORD

@@ -3,16 +3,20 @@ clapp_core.py,sha256=5tkzt7J4GKSv7Chv5Zoe9N0dv_sWlYGqYxmIn3dhEPY,1764
 clean_command.py,sha256=nmzitkdNo0Ovgi-tGPUxa9mkAIFzwEzGNaTm82MUdvw,6806
 cli_commands.py,sha256=ffJeRJTeipzHkSXhIUKrGzmymqtuv9bKCCQ2WGMQUD4,12482
 dependency_resolver.py,sha256=slskJhZJ5rRIv0Gcefd-cakHxdYl45bPwE4s_0APpsA,8562
-doctor_command.py,sha256=VpYx5isO-EI9EmCqlyAvGIJWasMaDDLmU7MDYBOz3kc,9446
+doctor_command.py,sha256=jLnvpU9Oglq553bwgF7fhAcUChZTMD2Qle9ZxNHPefc,7680
 info_command.py,sha256=b74Pl1-x_PSezALx-lS3FkEcVNTF7a9McTKk5XTDhjM,5629
-installer.py,sha256=4ojp3FCTw9-VxJhBzadO9oNBFWDHw5IQsMqXlwvKH_g,10039
+install_command.py,sha256=tkEMuezZ_-GWCikMfzZzkL0OjnRcyNixtW9OC749GDw,7789
+installer.py,sha256=EkQ5Z1Cq_Z5u_Ssv2Nc8hryI5E97x4D1QVjSqEHe0dE,10619
+list_command.py,sha256=qbeocvrg2eXRklxbYS3audQhYHGXTlMBk_tNh1cMxd0,8391
 main.py,sha256=aLwnLGv5AOjRsEBCyJKANKFKccpGEEo8PNe2_Mgm7w4,11806
 manifest_schema.py,sha256=IxfKuYgcIhILJrDMOm5vjSJn2jp7hPpUoxtjPMCPvbE,2201
 manifest_validator.py,sha256=MTI6c_sYfVakQ6aQUu5_qkukTh4H1FcSrT4uRdE6xIg,7990
 package_registry.py,sha256=LVu_IHHFxEvAsx7WxX04MD-jGXhRtwJzGTqDIieN9ao,4043
 package_runner.py,sha256=1aKQXTdHqfKFC0jZZ4qv_Io2-JS_WM6fWMwT7iunM2c,2668
 post_install_hint.py,sha256=wjMPCgRurZiGu6hv_se-XA36KqBCdeYdRCD1q7FrJzQ,4918
+publish_command.py,sha256=P05AFbu_mxcc1yAiwShN5Yi9PX1o_7TFXD1mowJcqJE,8589
 remote_registry.py,sha256=rPBIM_ESXUt0br5cARQ4YbzUoTda0G4e1KGzfyYMbpQ,8235
+uninstall_command.py,sha256=rQYbZ-XMw8Xxw1fmgGdDaBQmgBGqyJ_rTBZkvEV5HV0,7066
 validate_command.py,sha256=idaujErzrwuZNT6DYCVTVwZqBDEEi1GTxIXAGBgKMKM,7623
 version_command.py,sha256=Zk0EIUc2TAj1bN7EHpTqWmI3m-mH9sUpRz3T828ovvY,4370
 where_command.py,sha256=TcLoXLGmrPSHQuvlceVuuKBsfeadIwz-E0G_5okH14g,6420
@@ -25,16 +29,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.0.data/data/version.json,sha256=t-6ck4W0TVkQGg81ilCfG04OMivEbfsliJzbZudK3LY,238
-clapp_pm-1.0.0.dist-info/licenses/LICENSE,sha256=_hryv9pKR6udRexceUYuoYCJGmYBz7e-vRuFWmm38UY,1075
+clapp_pm-1.0.2.data/data/version.json,sha256=S7yOmQU4A-UqpUE3AX0vmjehgSS--fxuVEPG1YcIvDo,238
+clapp_pm-1.0.2.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.0.dist-info/METADATA,sha256=1sbjynftkku1Zi4GyLV4j8LvImw5g5KvTNrkb8JXIjI,3979
-clapp_pm-1.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-clapp_pm-1.0.0.dist-info/entry_points.txt,sha256=7j-3pQVpQfnaVzUV83g7zlCA30ePlnXkhHLAGGz9xrQ,36
-clapp_pm-1.0.0.dist-info/top_level.txt,sha256=dQhc-if0FtK86ImmFAUfXHm8hb6Y_ppQ6oMvD8tZ7ew,288
-clapp_pm-1.0.0.dist-info/RECORD,,
+clapp_pm-1.0.2.dist-info/METADATA,sha256=Yqpr_xf6m8POnPt648jyOtC2wTLHNALOsY3nnI6uKSw,3979
+clapp_pm-1.0.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+clapp_pm-1.0.2.dist-info/entry_points.txt,sha256=7j-3pQVpQfnaVzUV83g7zlCA30ePlnXkhHLAGGz9xrQ,36
+clapp_pm-1.0.2.dist-info/top_level.txt,sha256=90PY3qqc7ZdaDsLvwHtQiUG0OZqpsjxw_zkjiTTFY0I,351
+clapp_pm-1.0.2.dist-info/RECORD,,

{clapp_pm-1.0.0.dist-info → clapp_pm-1.0.2.dist-info}/top_level.txt

@@ -6,7 +6,9 @@ cli_commands
 dependency_resolver
 doctor_command
 info_command
+install_command
 installer
+list_command
 main
 manifest_schema
 manifest_validator
@@ -14,7 +16,9 @@ package_registry
 package_runner
 packages
 post_install_hint
+publish_command
 remote_registry
+uninstall_command
 validate_command
 version_command
 where_command

doctor_command.py

@@ -20,7 +20,6 @@ from check_env import (
     check_working_directory,
     check_apps_directory,
     check_permissions,
-    check_flet_installation
 )
 
 def check_clapp_config():
@@ -165,13 +164,25 @@ def check_python_modules():
     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),
@@ -187,93 +198,42 @@ def run_doctor():
         ("Yazma İzinleri", check_permissions),
         ("Disk Alanı", check_disk_space),
         ("Ağ Erişimi", check_network_access),
-        ("Flet Kurulumu", check_flet_installation),
         ("clapp Konfigürasyonu", check_clapp_config),
     ]
-    
     passed = 0
     failed = 0
     warnings = 0
-    
     results = []
-    
     for check_name, check_func in checks:
         try:
-            success, message = check_func()
-            results.append((check_name, success, message))
-            
-            if success:
-                print(f"✅ {check_name}: {message}")
+            ok, msg = check_func()
+            if ok:
+                print(f"✅ {check_name}: {msg}")
                 passed += 1
             else:
-                print(f"❌ {check_name}: {message}")
+                print(f"❌ {check_name}: {msg}")
                 failed += 1
+            results.append((check_name, ok, msg))
         except Exception as e:
-            error_msg = f"Hata - {str(e)}"
-            results.append((check_name, False, error_msg))
-            print(f"⚠️  {check_name}: {error_msg}")
-            warnings += 1
-    
-    # Özet
+            print(f"❌ {check_name}: Kontrol sırasında hata: {e}")
+            failed += 1
+            results.append((check_name, False, str(e)))
     print("\n" + "=" * 60)
-    print("📊 Tanılama Özeti:")
+    print(f"📊 Tanılama Özeti:")
     print(f"✅ Başarılı: {passed}")
     print(f"❌ Başarısız: {failed}")
     print(f"⚠️  Uyarı: {warnings}")
-    
-    # Genel durum
-    if failed == 0 and warnings == 0:
-        print("\n🎉 Mükemmel! Sisteminiz clapp için tamamen hazır.")
-        print("✨ Herhangi bir sorun bulunmadı.")
-    elif failed == 0:
-        print("\n✅ İyi! Sisteminiz clapp için genel olarak uygun.")
-        print("⚠️  Bazı küçük uyarılar var, ancak çalışmaya engel değil.")
-    else:
+    if failed > 0:
         print("\n🔧 Dikkat! Bazı sorunlar bulundu.")
         print("❌ Aşağıdaki sorunları çözmeniz önerilir:")
-    
-    # Detaylı öneriler
-    if failed > 0:
-        print("\n💡 Çözüm Önerileri:")
-        
-        for check_name, success, message in results:
-            if not success:
-                print(f"\n🔧 {check_name}:")
-                print(f"   Sorun: {message}")
-                
-                # Spesifik öneriler
-                if "Python" in check_name and "sürüm" in message.lower():
-                    print("   Çözüm: Python 3.8 veya daha yeni sürüm yükleyin")
-                elif "PATH" in check_name:
-                    print("   Çözüm: Python Scripts dizinini PATH'e ekleyin")
-                    print("   Detay: clapp check-env komutunu çalıştırın")
-                elif "apps/" in check_name:
-                    print("   Çözüm: mkdir apps komutu ile apps dizini oluşturun")
-                elif "Flet" in check_name:
-                    print("   Çözüm: pip install flet komutu ile Flet'i yükleyin")
-                elif "izin" in message.lower():
-                    print("   Çözüm: Dizin izinlerini kontrol edin veya farklı dizinde çalıştırın")
-                elif "disk" in message.lower():
-                    print("   Çözüm: Disk alanı açın veya farklı dizinde çalıştırın")
-                elif "ağ" in message.lower():
-                    print("   Çözüm: İnternet bağlantınızı kontrol edin")
-    
-    # Sonraki adımlar
-    print("\n🚀 Sonraki Adımlar:")
-    if failed == 0:
-        print("• clapp list - Yüklü uygulamaları listeleyin")
-        print("• clapp gui - Grafik arayüzü başlatın")
-        print("• clapp --help - Tüm komutları görün")
+        for name, ok, msg in results:
+            if not ok:
+                print(f"\n🔧 {name}:\n   Sorun: {msg}")
     else:
-        print("• Yukarıdaki sorunları çözün")
-        print("• clapp doctor - Tekrar tanılama çalıştırın")
-        print("• clapp check-env - Temel kontrolleri yapın")
-    
+        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")
-    
-    return failed == 0
 
 if __name__ == "__main__":
     run_doctor() 

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() 

installer.py

@@ -7,81 +7,84 @@ import json
 from manifest_validator import validate_manifest_verbose
 from package_registry import app_exists
 
+def find_app_folder(extract_path, app_name):
+    """
+    Zip çıkarıldıktan sonra, extract_path altında **/packages/{app_name} klasörünü bulur.
+    """
+    for root, dirs, files in os.walk(extract_path):
+        if os.path.basename(root) == app_name and os.path.basename(os.path.dirname(root)) == "packages":
+            return root
+    return None
+
+
 def install_package(source, force=False):
     """
     Bir .clapp paketini zip dosyasından veya URL'den yükler.
-    
-    Args:
-        source (str): Yerel zip dosya yolu veya uzak URL
-        force (bool): Mevcut uygulamanın üzerine yazılmasına izin ver
-        
-    Returns:
-        tuple: (success: bool, message: str)
     """
     temp_dir = None
-    
     try:
-        # Geçici dizin oluştur
         temp_dir = tempfile.mkdtemp()
-        
-        # Kaynak türünü belirle (URL mu dosya yolu mu)
         if source.startswith(('http://', 'https://')):
-            # URL'den indir
             zip_path = download_package(source, temp_dir)
             if not zip_path:
                 return False, "Paket indirilemedi"
         else:
-            # Yerel dosya
             if not os.path.exists(source):
                 return False, f"Dosya bulunamadı: {source}"
             zip_path = source
-        
-        # Zip dosyasını çıkart
         extract_path = os.path.join(temp_dir, "extracted")
         success, message = extract_package(zip_path, extract_path)
         if not success:
             return False, message
-        
-        # Manifest'i yükle ve doğrula
-        manifest_path = os.path.join(extract_path, "manifest.json")
-        is_valid, errors = validate_manifest_file(manifest_path)
+
+        # --- YENİ: Doğru app klasörünü bul ---
+        # Önce manifesti bulmak için tüm app klasörlerini tara
+        app_folder = None
+        manifest = None
+        manifest_path = None
+        # Tüm packages altındaki app klasörlerini bul
+        for root, dirs, files in os.walk(extract_path):
+            if "manifest.json" in files:
+                with open(os.path.join(root, "manifest.json"), 'r', encoding='utf-8') as f:
+                    try:
+                        m = json.load(f)
+                        if 'name' in m:
+                            app_folder = root
+                            manifest = m
+                            manifest_path = os.path.join(root, "manifest.json")
+                            break
+                    except Exception:
+                        continue
+        if not app_folder or not manifest:
+            return False, "Uygulama klasörü bulunamadı: manifest.json"
+        app_name = manifest['name']
+
+        # --- YENİ: Sadece packages/{app_name} klasörünü bul ve kopyala ---
+        app_real_folder = find_app_folder(extract_path, app_name)
+        if not app_real_folder:
+            return False, f"Uygulama klasörü bulunamadı: packages/{app_name}"
+
+        # Manifesti doğrula
+        is_valid, errors = validate_manifest_file(os.path.join(app_real_folder, "manifest.json"))
         if not is_valid:
             error_msg = "Manifest doğrulama hatası:\n" + "\n".join(errors)
             return False, error_msg
-        
-        # Manifest'i yükle
-        with open(manifest_path, 'r', encoding='utf-8') as f:
-            manifest = json.load(f)
-        
-        app_name = manifest['name']
-        
-        # Uygulama zaten var mı kontrol et
-        if app_exists(app_name) and not force:
-            return False, f"Uygulama '{app_name}' zaten yüklü. --force kullanarak üzerine yazabilirsiniz."
-        
+
         # Giriş dosyasının varlığını kontrol et
         entry_file = manifest['entry']
-        entry_path = os.path.join(extract_path, entry_file)
+        entry_path = os.path.join(app_real_folder, entry_file)
         if not os.path.exists(entry_path):
             return False, f"Giriş dosyası bulunamadı: {entry_file}"
-        
+
         # Hedef dizini oluştur
         target_dir = os.path.join("apps", app_name)
-        
-        # Mevcut dizini sil (eğer varsa)
         if os.path.exists(target_dir):
             shutil.rmtree(target_dir)
-        
-        # Dosyaları kopyala
-        shutil.copytree(extract_path, target_dir)
-        
+        shutil.copytree(app_real_folder, target_dir)
         return True, f"✅ '{app_name}' başarıyla yüklendi!"
-        
     except Exception as e:
         return False, f"Yükleme hatası: {e}"
-    
     finally:
-        # Geçici dizini temizle
         if temp_dir and os.path.exists(temp_dir):
             shutil.rmtree(temp_dir)
 

list_command.py

@@ -0,0 +1,262 @@
+#!/usr/bin/env python3
+"""
+list_command.py - clapp List Command
+
+Bu modül 'clapp list' komutunu uygular.
+Kurulu uygulamaları farklı formatlarda listeler.
+"""
+
+import os
+import json
+import sys
+from pathlib import Path
+from typing import List, Dict, Any, Optional
+
+def get_apps_directory() -> str:
+    """Uygulamaların kurulu olduğu dizini döndürür"""
+    # Kullanıcının home dizininde .clapp klasörü
+    home_dir = Path.home()
+    clapp_dir = home_dir / ".clapp"
+    apps_dir = clapp_dir / "apps"
+    
+    return str(apps_dir)
+
+def load_app_manifest(app_path: str) -> Optional[Dict[str, Any]]:
+    """Uygulama manifest'ini yükler"""
+    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:
+            return json.load(f)
+    except Exception:
+        return None
+
+def get_installed_apps_with_info() -> List[Dict[str, Any]]:
+    """Kurulu uygulamaların detaylı bilgilerini döndürür"""
+    apps_dir = get_apps_directory()
+    apps = []
+    
+    if not os.path.exists(apps_dir):
+        return apps
+    
+    for item in os.listdir(apps_dir):
+        item_path = os.path.join(apps_dir, item)
+        
+        if not os.path.isdir(item_path) or item.startswith('.'):
+            continue
+        
+        manifest = load_app_manifest(item_path)
+        
+        if manifest:
+            app_info = {
+                'name': manifest.get('name', item),
+                'version': manifest.get('version', '?'),
+                'language': manifest.get('language', '?'),
+                'description': manifest.get('description', 'Açıklama yok'),
+                'entry': manifest.get('entry', '?'),
+                'dependencies': manifest.get('dependencies', []),
+                'folder': item,
+                'path': item_path
+            }
+        else:
+            app_info = {
+                'name': item,
+                'version': '?',
+                'language': '?',
+                'description': 'Manifest bulunamadı',
+                'entry': '?',
+                'dependencies': [],
+                'folder': item,
+                'path': item_path
+            }
+        
+        apps.append(app_info)
+    
+    return apps
+
+def format_table_output(apps: List[Dict[str, Any]]) -> str:
+    """Uygulamaları tablo formatında formatlar"""
+    if not apps:
+        return "📭 Hiç uygulama kurulu değil."
+    
+    # Başlık
+    output = []
+    output.append(f"📦 Kurulu Uygulamalar ({len(apps)})")
+    output.append("=" * 80)
+    
+    # Sütun başlıkları
+    output.append(f"{'Ad':<20} {'Sürüm':<10} {'Dil':<10} {'Açıklama':<30}")
+    output.append("-" * 80)
+    
+    # Uygulamalar
+    for app in sorted(apps, key=lambda x: x['name'].lower()):
+        name = app['name'][:19]
+        version = app['version'][:9]
+        language = app['language'][:9]
+        description = app['description'][:29]
+        
+        output.append(f"{name:<20} {version:<10} {language:<10} {description:<30}")
+    
+    return "\n".join(output)
+
+def format_simple_output(apps: List[Dict[str, Any]]) -> str:
+    """Uygulamaları basit liste formatında formatlar"""
+    if not apps:
+        return "📭 Hiç uygulama kurulu değil."
+    
+    output = []
+    output.append(f"📦 Kurulu Uygulamalar ({len(apps)}):")
+    
+    for app in sorted(apps, key=lambda x: x['name'].lower()):
+        name = app['name']
+        version = app['version']
+        language = app['language']
+        output.append(f"  • {name} (v{version}) - {language}")
+    
+    return "\n".join(output)
+
+def format_json_output(apps: List[Dict[str, Any]]) -> str:
+    """Uygulamaları JSON formatında formatlar"""
+    return json.dumps(apps, indent=2, ensure_ascii=False)
+
+def format_detailed_output(apps: List[Dict[str, Any]]) -> str:
+    """Uygulamaları detaylı formatda formatlar"""
+    if not apps:
+        return "📭 Hiç uygulama kurulu değil."
+    
+    output = []
+    output.append(f"📦 Kurulu Uygulamalar ({len(apps)})")
+    output.append("=" * 60)
+    
+    for i, app in enumerate(sorted(apps, key=lambda x: x['name'].lower()), 1):
+        output.append(f"\n{i}. {app['name']}")
+        output.append(f"   Sürüm: {app['version']}")
+        output.append(f"   Dil: {app['language']}")
+        output.append(f"   Açıklama: {app['description']}")
+        output.append(f"   Entry: {app['entry']}")
+        output.append(f"   Klasör: {app['folder']}")
+        output.append(f"   Yol: {app['path']}")
+        
+        if app['dependencies']:
+            output.append(f"   Bağımlılıklar: {', '.join(app['dependencies'])}")
+        else:
+            output.append(f"   Bağımlılıklar: Yok")
+    
+    return "\n".join(output)
+
+def filter_apps_by_language(apps: List[Dict[str, Any]], language: str) -> List[Dict[str, Any]]:
+    """Uygulamaları dile göre filtreler"""
+    return [app for app in apps if app['language'].lower() == language.lower()]
+
+def filter_apps_by_name(apps: List[Dict[str, Any]], search_term: str) -> List[Dict[str, Any]]:
+    """Uygulamaları isme göre filtreler"""
+    search_term = search_term.lower()
+    return [app for app in apps if search_term in app['name'].lower() or search_term in app['description'].lower()]
+
+def list_apps(format_type: str = "table", language_filter: str = None, search_term: str = None) -> str:
+    """
+    Ana list fonksiyonu
+    
+    Args:
+        format_type: Çıktı formatı (table, simple, json, detailed)
+        language_filter: Dil filtresi (python, lua, vb.)
+        search_term: Arama terimi
+        
+    Returns:
+        Formatlanmış çıktı
+    """
+    apps = get_installed_apps_with_info()
+    
+    # Filtreleri uygula
+    if language_filter:
+        apps = filter_apps_by_language(apps, language_filter)
+    
+    if search_term:
+        apps = filter_apps_by_name(apps, search_term)
+    
+    # Formatı uygula
+    if format_type == "json":
+        return format_json_output(apps)
+    elif format_type == "simple":
+        return format_simple_output(apps)
+    elif format_type == "detailed":
+        return format_detailed_output(apps)
+    else:  # table (default)
+        return format_table_output(apps)
+
+def show_help():
+    """Yardım mesajını gösterir"""
+    help_text = """
+clapp list - Kurulu uygulamaları listeler
+
+Kullanım:
+    python list_command.py [seçenekler]
+
+Seçenekler:
+    --format FORMAT     Çıktı formatı (table, simple, json, detailed)
+    --language LANG     Dil filtresi (python, lua, vb.)
+    --search TERM       Arama terimi (ad veya açıklamada)
+    --help             Bu yardım mesajını göster
+
+Örnekler:
+    python list_command.py
+    python list_command.py --format json
+    python list_command.py --format simple
+    python list_command.py --format detailed
+    python list_command.py --language python
+    python list_command.py --search calculator
+    python list_command.py --language python --format detailed
+    """
+    print(help_text.strip())
+
+def main():
+    """CLI entry point"""
+    # Komut satırı argümanlarını parse et
+    args = sys.argv[1:]
+    
+    if "--help" in args or "-h" in args:
+        show_help()
+        sys.exit(0)
+    
+    format_type = "table"
+    language_filter = None
+    search_term = None
+    
+    i = 0
+    while i < len(args):
+        arg = args[i]
+        
+        if arg == "--format" and i + 1 < len(args):
+            format_type = args[i + 1]
+            i += 2
+        elif arg == "--language" and i + 1 < len(args):
+            language_filter = args[i + 1]
+            i += 2
+        elif arg == "--search" and i + 1 < len(args):
+            search_term = args[i + 1]
+            i += 2
+        else:
+            print(f"❌ Bilinmeyen argüman: {arg}")
+            print("Yardım için: python list_command.py --help")
+            sys.exit(1)
+    
+    # Format kontrolü
+    valid_formats = ["table", "simple", "json", "detailed"]
+    if format_type not in valid_formats:
+        print(f"❌ Geçersiz format: {format_type}")
+        print(f"Geçerli formatlar: {', '.join(valid_formats)}")
+        sys.exit(1)
+    
+    # Uygulamaları listele
+    try:
+        output = list_apps(format_type, language_filter, search_term)
+        print(output)
+    except Exception as e:
+        print(f"❌ Hata: {e}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main() 

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() 

uninstall_command.py

@@ -0,0 +1,215 @@
+#!/usr/bin/env python3
+"""
+uninstall_command.py - clapp Uninstall Command
+
+Bu modül 'clapp uninstall <app_name>' komutunu uygular.
+Kurulu uygulamaları güvenli bir şekilde kaldırır.
+"""
+
+import os
+import shutil
+import sys
+from pathlib import Path
+from typing import Tuple, List
+
+def get_apps_directory() -> str:
+    """Uygulamaların kurulu olduğu dizini döndürür"""
+    # Kullanıcının home dizininde .clapp klasörü
+    home_dir = Path.home()
+    clapp_dir = home_dir / ".clapp"
+    apps_dir = clapp_dir / "apps"
+    
+    return str(apps_dir)
+
+def get_installed_apps() -> List[str]:
+    """Kurulu uygulamaların listesini döndürür"""
+    apps_dir = get_apps_directory()
+    
+    if not os.path.exists(apps_dir):
+        return []
+    
+    apps = []
+    for item in os.listdir(apps_dir):
+        item_path = os.path.join(apps_dir, item)
+        if os.path.isdir(item_path) and not item.startswith('.'):
+            # manifest.json varlığını kontrol et
+            manifest_path = os.path.join(item_path, "manifest.json")
+            if os.path.exists(manifest_path):
+                apps.append(item)
+    
+    return apps
+
+def is_app_installed(app_name: str) -> bool:
+    """Uygulamanın kurulu olup olmadığını kontrol eder"""
+    apps_dir = get_apps_directory()
+    app_path = os.path.join(apps_dir, app_name)
+    
+    if not os.path.exists(app_path):
+        return False
+    
+    if not os.path.isdir(app_path):
+        return False
+    
+    # manifest.json varlığını kontrol et
+    manifest_path = os.path.join(app_path, "manifest.json")
+    return os.path.exists(manifest_path)
+
+def get_app_info(app_name: str) -> Tuple[bool, str, dict]:
+    """Uygulamanın bilgilerini getirir"""
+    apps_dir = get_apps_directory()
+    app_path = os.path.join(apps_dir, app_name)
+    manifest_path = os.path.join(app_path, "manifest.json")
+    
+    try:
+        import json
+        with open(manifest_path, 'r', encoding='utf-8') as f:
+            manifest = json.load(f)
+        
+        return True, "Bilgiler alındı", manifest
+    except Exception as e:
+        return False, f"Manifest okunamadı: {e}", {}
+
+def confirm_uninstall(app_name: str, app_info: dict, skip_confirmation: bool = False) -> bool:
+    """Kullanıcıdan kaldırma onayı alır"""
+    if skip_confirmation:
+        return True
+    
+    print(f"\n📋 Kaldırılacak uygulama:")
+    print(f"   Ad: {app_info.get('name', app_name)}")
+    print(f"   Sürüm: {app_info.get('version', 'Bilinmiyor')}")
+    print(f"   Dil: {app_info.get('language', 'Bilinmiyor')}")
+    print(f"   Açıklama: {app_info.get('description', 'Yok')}")
+    
+    while True:
+        response = input(f"\n❓ '{app_name}' uygulamasını kaldırmak istediğinizden emin misiniz? (e/h): ").lower().strip()
+        if response in ['e', 'evet', 'y', 'yes']:
+            return True
+        elif response in ['h', 'hayır', 'n', 'no']:
+            return False
+        else:
+            print("Lütfen 'e' (evet) veya 'h' (hayır) giriniz.")
+
+def remove_app_directory(app_name: str) -> Tuple[bool, str]:
+    """Uygulama klasörünü güvenli şekilde kaldırır"""
+    try:
+        apps_dir = get_apps_directory()
+        app_path = os.path.join(apps_dir, app_name)
+        
+        # Güvenlik kontrolü - sadece .clapp/apps altındaki klasörleri sil
+        if not app_path.startswith(apps_dir):
+            return False, "Güvenlik hatası: Geçersiz klasör yolu"
+        
+        if not os.path.exists(app_path):
+            return False, "Uygulama klasörü bulunamadı"
+        
+        # Klasörü sil
+        shutil.rmtree(app_path)
+        
+        return True, f"Uygulama klasörü kaldırıldı: {app_path}"
+        
+    except PermissionError:
+        return False, "İzin hatası: Klasör kaldırılamadı"
+    except Exception as e:
+        return False, f"Kaldırma hatası: {e}"
+
+def uninstall_app(app_name: str, skip_confirmation: bool = False) -> Tuple[bool, str]:
+    """
+    Ana uninstall fonksiyonu
+    
+    Args:
+        app_name: Kaldırılacak uygulamanın adı
+        skip_confirmation: Onay sorma (--yes flag için)
+        
+    Returns:
+        (success, message)
+    """
+    print(f"🗑️  Kaldırma başlatılıyor: {app_name}")
+    print("=" * 50)
+    
+    # 1. Uygulama kurulu mu kontrol et
+    print("1️⃣ Uygulama kontrol ediliyor...")
+    
+    if not is_app_installed(app_name):
+        installed_apps = get_installed_apps()
+        if installed_apps:
+            return False, f"Uygulama kurulu değil: {app_name}\nKurulu uygulamalar: {', '.join(installed_apps)}"
+        else:
+            return False, f"Uygulama kurulu değil: {app_name}\nHiç uygulama kurulu değil."
+    
+    print(f"✅ {app_name} kurulu")
+    
+    # 2. Uygulama bilgilerini al
+    print("2️⃣ Uygulama bilgileri alınıyor...")
+    info_success, info_message, app_info = get_app_info(app_name)
+    
+    if not info_success:
+        print(f"⚠️  {info_message}")
+        app_info = {'name': app_name}
+    
+    # 3. Kullanıcı onayı
+    if not skip_confirmation:
+        print("3️⃣ Kullanıcı onayı bekleniyor...")
+        if not confirm_uninstall(app_name, app_info, skip_confirmation):
+            return False, "Kaldırma işlemi iptal edildi"
+    
+    # 4. Uygulamayı kaldır
+    print("4️⃣ Uygulama kaldırılıyor...")
+    remove_success, remove_message = remove_app_directory(app_name)
+    
+    if not remove_success:
+        return False, remove_message
+    
+    return True, f"🎉 '{app_name}' başarıyla kaldırıldı!"
+
+def list_installed_apps():
+    """Kurulu uygulamaları listeler"""
+    apps = get_installed_apps()
+    
+    if not apps:
+        print("📭 Hiç uygulama kurulu değil.")
+        return
+    
+    print(f"📦 Kurulu uygulamalar ({len(apps)}):")
+    print("-" * 30)
+    
+    for app_name in sorted(apps):
+        info_success, _, app_info = get_app_info(app_name)
+        if info_success:
+            version = app_info.get('version', '?')
+            language = app_info.get('language', '?')
+            print(f"  • {app_name} (v{version}) - {language}")
+        else:
+            print(f"  • {app_name} - bilgi alınamadı")
+
+def main():
+    """CLI entry point"""
+    if len(sys.argv) < 2:
+        print("Kullanım: python uninstall_command.py <app_name> [--yes]")
+        print("         python uninstall_command.py --list")
+        print()
+        print("Örnekler:")
+        print("  python uninstall_command.py hello-python")
+        print("  python uninstall_command.py hello-python --yes")
+        print("  python uninstall_command.py --list")
+        sys.exit(1)
+    
+    # --list flag kontrolü
+    if sys.argv[1] == "--list":
+        list_installed_apps()
+        sys.exit(0)
+    
+    app_name = sys.argv[1]
+    skip_confirmation = "--yes" in sys.argv
+    
+    success, message = uninstall_app(app_name, skip_confirmation)
+    
+    print("\n" + "=" * 50)
+    if success:
+        print(f"✅ {message}")
+        sys.exit(0)
+    else:
+        print(f"❌ {message}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()