appforge-cli 1.0.0__tar.gz

appforge_cli-1.0.0/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: appforge-cli
+Version: 1.0.0
+Summary: Convert web, Flutter, and native apps into Android/iOS apps automatically using cloud builds.
+Author: AppForge Team
+Author-email: AppForge Team <juniorsir.bot@gmail.com>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Environment :: Console
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: requests
+Dynamic: author

appforge_cli-1.0.0/appforge/ai.py

@@ -0,0 +1,58 @@
+import os
+from .utils import print_info, print_success, CYAN, RESET, GRAY
+
+# Mapping keywords in JS/TS to Capacitor Plugins
+AI_KNOWLEDGE_BASE = {
+    "navigator.geolocation": {
+        "plugin": "@capacitor/geolocation",
+        "feature": "Geolocation (GPS)",
+        "desc": "Found location tracking code"
+    },
+    "getUserMedia": {
+        "plugin": "@capacitor/camera",
+        "feature": "Camera / Microphone",
+        "desc": "Found camera/audio access code"
+    },
+    "Notification.requestPermission": {
+        "plugin": "@capacitor/push-notifications",
+        "feature": "Push Notifications",
+        "desc": "Found notification request code"
+    },
+    "navigator.vibrate": {
+        "plugin": "@capacitor/haptics",
+        "feature": "Haptics (Vibration)",
+        "desc": "Found vibration code"
+    },
+    "localStorage": {
+        "plugin": "@capacitor/preferences",
+        "feature": "Secure Storage",
+        "desc": "Found local storage usage"
+    }
+}
+
+def scan_codebase_for_permissions():
+    """Scans the project files to intelligently recommend native permissions."""
+    print_info(f"{CYAN}🤖 AI Agent scanning codebase for native features...{RESET}")
+    
+    found_plugins = {}
+    
+    # Walk through the project directory
+    for root, dirs, files in os.walk('.'):
+        # Ignore heavy or irrelevant folders
+        dirs[:] = [d for d in dirs if d not in ['node_modules', '.git', 'android', 'ios', 'dist', 'build', '.next', '.nuxt']]
+        
+        for file in files:
+            if file.endswith(('.js', '.ts', '.jsx', '.tsx', '.vue', '.svelte', '.html')):
+                file_path = os.path.join(root, file)
+                try:
+                    with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
+                        content = f.read()
+                        
+                        # Check against our AI knowledge base
+                        for keyword, data in AI_KNOWLEDGE_BASE.items():
+                            if keyword in content and data["plugin"] not in found_plugins:
+                                found_plugins[data["plugin"]] = data
+                except Exception:
+                    pass
+                    
+    return found_plugins

appforge_cli-1.0.0/appforge/capacitor.py

@@ -0,0 +1,80 @@
+import os
+import json
+import shutil
+import subprocess
+from .utils import print_success, print_error, print_info, run_with_spinner
+
+def run_cmd(command, hide_output=True):
+    try:
+        stdout = subprocess.DEVNULL if hide_output else None
+        subprocess.run(command, shell=True, check=True, stdout=stdout, stderr=stdout)
+    except subprocess.CalledProcessError as e:
+        error_message = f"Command '{command}' failed. Please check your setup."
+        print_error(error_message)
+
+
+def generate_capacitor_config(app_name, package_id, web_dir):
+    config = {
+      "appId": package_id,
+      "appName": app_name,
+      "webDir": web_dir,
+      "server": {
+        "androidScheme": "https"
+      }
+    }
+    with open("capacitor.config.json", "w") as f:
+        json.dump(config, f, indent=2)
+
+def setup_capacitor(web_dir, platforms=["android"]):
+    if not os.path.exists("package.json"):
+        run_with_spinner(lambda: run_cmd("npm init -y"), "Initializing npm project")
+    
+    run_with_spinner(lambda: run_cmd("npm install @capacitor/core"), "Installing Capacitor Core")
+    run_with_spinner(lambda: run_cmd("npm install -D @capacitor/cli"), "Installing Capacitor CLI")
+    
+    app_name = "Generated App"
+    package_id = "com.appforge.generated"
+    generate_capacitor_config(app_name, package_id, web_dir)
+    print_success("Config generated (capacitor.config.json)")
+
+    if not os.path.exists(web_dir):
+        os.makedirs(web_dir)
+        if os.path.exists("index.html"):
+            shutil.copy("index.html", os.path.join(web_dir, "index.html"))
+        else:
+            with open(os.path.join(web_dir, "index.html"), "w") as f:
+                f.write("<h1>AppForge Built App</h1>")
+
+    # Add selected platforms
+    if "android" in platforms:
+        run_with_spinner(lambda: run_cmd("npm install @capacitor/android"), "Installing Android dependencies")
+        if not os.path.exists("android"):
+            run_with_spinner(lambda: run_cmd("npx cap add android", hide_output=True), "Adding native Android platform")
+            
+    if "ios" in platforms:
+        run_with_spinner(lambda: run_cmd("npm install @capacitor/ios"), "Installing iOS dependencies")
+        if not os.path.exists("ios"):
+            run_with_spinner(lambda: run_cmd("npx cap add ios", hide_output=True), "Adding native iOS platform")
+
+def apply_configuration(app_name, package_id, icon_path, splash_img, splash_bg, web_dir):
+    generate_capacitor_config(app_name, package_id, web_dir)
+    print_success(f"Config updated for '{app_name}'")
+    
+    if icon_path and os.path.exists(icon_path):
+        print_success("Icon path saved")
+    
+    if splash_img and os.path.exists(splash_img):
+        print_success("Splash image path saved")
+    
+    if splash_bg:
+        print_success(f"Splash background color set to {splash_bg}")
+
+def install_plugins(plugins_list):
+    if not plugins_list:
+        return
+        
+    for plugin in plugins_list:
+        run_with_spinner(
+            lambda p=plugin: run_cmd(f"npm install {p}", hide_output=True), 
+            f"Installing native plugin: {plugin}"  # <-- FIXED THIS LINE
+        )

appforge_cli-1.0.0/appforge/cli.py

@@ -0,0 +1,199 @@
+import sys
+import argparse
+from .utils import print_header, print_footer, print_info, print_success, print_error, prompt, GRAY, RESET, CYAN, BOLD
+from .detector import detect_project
+from .capacitor import setup_capacitor, apply_configuration, install_plugins
+from .config import save_local_config, load_local_config, global_config_exists, create_global_config
+from .github import push_and_build, check_status, download_apk
+
+from .ai import scan_codebase_for_permissions
+
+def init_project():
+    project_info = detect_project()
+    category = project_info.get("category", "web")
+    proj_type = project_info.get("type", "unknown")
+    
+    save_local_config({"category": category, "project_type": proj_type})
+
+    if category == "web":
+        web_dir = prompt("Confirm web build directory", project_info["webDir"])
+        platform_choice = prompt("Select platform (android, ios, both)", "android").lower()
+        if platform_choice == "both": platforms = ["android", "ios"]
+        elif platform_choice == "ios": platforms = ["ios"]
+        else: platforms = ["android"]
+        
+        save_local_config({"webDir": web_dir, "platform": platform_choice})
+        setup_capacitor(web_dir, platforms)
+        
+        # --- AI PERMISSION SYSTEM (FIXED) ---
+        print("")
+        detected_features = scan_codebase_for_permissions()
+        if detected_features:
+            print_success(f"AI detected {len(detected_features)} native features required by your code:")
+            
+            # This is the loop I accidentally deleted!
+            for data in detected_features.values():
+                print(f"  {CYAN}●{RESET} {data['feature']} {GRAY}({data['desc']}){RESET}")
+                
+            apply_ai = prompt("Auto-configure these native permissions?", "y").lower()
+            if apply_ai in ['y', 'yes']:
+                install_plugins(list(detected_features.keys()))
+                print_success("Native permissions and plugins configured securely.")
+            else:
+                print_info("Skipped auto-configuration.")
+        else:
+            print_info("AI scan complete. No special native permissions detected.")
+        # ------------------------------------
+
+    else:
+        print_info(f"Native {proj_type} project detected. Bypassing Capacitor setup.")
+        platform_choice = prompt("Select platform to build in cloud (android, ios, both)", "android").lower()
+        save_local_config({"platform": platform_choice})
+
+    print_success("Ready to send to the AppForge Cloud Builder.")
+
+def configure_project():
+    config = load_local_config()
+    print_info("Interactive Configuration")
+    app_name = prompt("App name", config.get("appName", "My App"))
+    package_id = prompt("Package ID", config.get("packageId", "com.example.app"))
+    icon_path = prompt("Icon path (local PNG)", config.get("iconPath", ""))
+    splash_img = prompt("Splash image (local PNG)", config.get("splashImg", ""))
+    splash_bg = prompt("Splash background color (HEX)", config.get("splashBg", "#ffffff"))
+
+    new_config = {
+        "appName": app_name,
+        "packageId": package_id,
+        "iconPath": icon_path,
+        "splashImg": splash_img,
+        "splashBg": splash_bg
+    }
+    save_local_config(new_config)
+
+    web_dir = config.get("webDir", "dist")
+    apply_configuration(app_name, package_id, icon_path, splash_img, splash_bg, web_dir)
+    return new_config
+
+def display_app_details(config):
+    print(f"{BOLD}App Configuration:{RESET}")
+    print(f"  {GRAY}Name:{RESET}          {config.get('appName', 'Not set')}")
+    print(f"  {GRAY}Package ID:{RESET}    {config.get('packageId', 'Not set')}")
+    print(f"  {GRAY}Web Directory:{RESET} {config.get('webDir', 'Not set')}")
+    print(f"  {GRAY}Icon:{RESET}          {config.get('iconPath', 'Not set')}")
+    print(f"  {GRAY}Splash Image:{RESET}  {config.get('splashImg', 'Not set')}")
+    print(f"  {GRAY}Splash Color:{RESET}  {config.get('splashBg', 'Not set')}")
+    print("-" * 30)
+
+def build_app():
+    config = load_local_config()
+    if not config:
+        print_error("Project not initialized. Run 'appforge init' first.")
+
+    app_name = config.get("appName")
+    package_id = config.get("packageId")
+    platform = config.get("platform", "android")
+    config_was_updated = False
+
+    if not app_name or not package_id:
+        print_info("Some required app details are missing. Let's set them up.")
+        new_app_name = prompt("App name", app_name or "My App")
+        new_package_id = prompt("Package ID", package_id or "com.example.app")
+        new_platform = prompt("Platform (android, ios, both)", platform)
+
+        config['appName'] = new_app_name
+        config['packageId'] = new_package_id
+        config['platform'] = new_platform.lower()
+        config_was_updated = True
+
+    if config_was_updated:
+        save_local_config(config)
+        apply_configuration(
+            config['appName'], config['packageId'], config.get('iconPath'),
+            config.get('splashImg'), config.get('splashBg'), config.get('webDir')
+        )
+        print_success("App details updated.\n")
+
+    print_info("Ready to build with the following configuration:")
+    display_app_details(config)
+    print(f"  {GRAY}Target Platform:{RESET} {config.get('platform', 'android')}\n")
+
+    action = prompt("Proceed with build? (Y/n)", default="y").lower()
+
+    if action in ['y', 'yes', '']:
+        # Pass the platform to the push_and_build function!
+        push_and_build(config.get('platform', 'android'))
+        print_success("Your app is now building in the cloud!")
+        print_info("Run 'appforge status' to check its progress.")
+    else:
+        print_info("Build cancelled.")
+
+def status_check():
+    check_status()
+
+def download_app():
+    download_apk()
+
+def show_help():
+    print("Commands:")
+    print("  appforge init       - Initialize an AppForge project")
+    print("  appforge configure  - Open interactive settings")
+    print("  appforge build      - Package project and send to build repo")
+    print("  appforge status     - Check build status")
+    print("  appforge download   - Download the built APK")
+    print("  appforge help       - Show this help message")
+
+def run_first_time_setup():
+    """The animated welcome sequence for the very first run."""
+    welcome_message = f"{BOLD}▲ AppForge{RESET} - Universal App Builder"
+    
+    # Typing animation
+    for char in welcome_message:
+        sys.stdout.write(char)
+        sys.stdout.flush()
+        time.sleep(0.05)
+    print("\n")
+    time.sleep(0.5)
+    
+    print_success("Installation complete!")
+    print_info("Welcome to the AppForge ecosystem.")
+    
+    # Create the global config to ensure this only runs once
+    create_global_config()
+    
+    print("\nGetting Started:")
+    print("  1. `cd` into your project directory")
+    print("  2. Run `appforge init` to begin\n")
+    
+    show_help()
+    print_footer()
+    sys.exit(0)
+
+def main():
+
+    if not global_config_exists():
+        run_first_time_setup()
+
+    print_header()
+    
+    parser = argparse.ArgumentParser(description="AppForge CLI", add_help=False)
+    parser.add_argument("command", nargs="?", default="help", help="Command to run")
+    args = parser.parse_args()
+
+    try:
+        if args.command == "init":
+            init_project()
+        elif args.command == "configure":
+            configure_project()
+        elif args.command == "build":
+            build_app()
+        elif args.command == "status":
+            status_check()
+        elif args.command == "download":
+            download_app()
+        else:
+            show_help()
+    finally:
+        print_footer()
+
+if __name__ == "__main__":
+    main()

appforge_cli-1.0.0/appforge/config.py

@@ -0,0 +1,35 @@
+import os
+import json
+import uuid
+from .utils import print_error
+
+LOCAL_CONFIG_FILE = ".appforge.json"
+
+def load_local_config():
+    if not os.path.exists(LOCAL_CONFIG_FILE):
+        return {}
+    with open(LOCAL_CONFIG_FILE, "r") as f:
+        return json.load(f)
+
+def save_local_config(data):
+    config = load_local_config()
+    config.update(data)
+    with open(LOCAL_CONFIG_FILE, "w") as f:
+        json.dump(config, f, indent=2)
+
+def get_app_id():
+    config = load_local_config()
+    if "app_id" not in config:
+        new_id = str(uuid.uuid4())[:8] # Generate a short 8-character unique ID
+        save_local_config({"app_id": new_id})
+        return new_id
+    return config["app_id"]
+
+def global_config_exists():
+    """Checks if the global configuration file has been created."""
+    return os.path.exists(GLOBAL_CONFIG_FILE)
+
+def create_global_config(initial_data={}):
+    """Creates the global config file, marking the first-run as complete."""
+    with open(GLOBAL_CONFIG_FILE, "w") as f:
+        json.dump(initial_data, f, indent=2)

appforge_cli-1.0.0/appforge/detector.py

@@ -0,0 +1,49 @@
+import os
+import json
+from .utils import print_info, print_warning
+
+def detect_project():
+    # 1. Detect Flutter
+    if os.path.exists("pubspec.yaml"):
+        print_info("Detected Flutter project")
+        return {"type": "flutter", "category": "native", "webDir": None}
+
+    # 2. Detect Native Android (Kotlin/Java)
+    if os.path.exists("build.gradle") or os.path.exists("build.gradle.kts"):
+        print_info("Detected Native Android (Kotlin/Java) project")
+        return {"type": "android_native", "category": "native", "webDir": None}
+
+    # 3. Detect Native iOS (Swift/Objective-C)
+    if glob_exists("*.xcodeproj") or glob_exists("*.xcworkspace"):
+        print_info("Detected Native iOS (Swift/Objective-C) project")
+        return {"type": "ios_native", "category": "native", "webDir": None}
+
+    # 4. Detect Web Frameworks (Needs Capacitor)
+    if not os.path.exists("package.json"):
+        if os.path.exists("index.html"):
+            print_info("Detected plain HTML/CSS project")
+            return {"type": "html", "category": "web", "webDir": "www"}
+        return {"type": "unknown", "category": "web", "webDir": "www"}
+
+    with open("package.json", "r") as f:
+        try: pkg = json.load(f)
+        except json.JSONDecodeError: return {"type": "unknown", "category": "web", "webDir": "www"}
+
+    deps = pkg.get("dependencies", {})
+    dev_deps = pkg.get("devDependencies", {})
+    all_deps = {**deps, **dev_deps}
+    scripts_str = json.dumps(pkg.get("scripts", {}))
+
+    if "nuxt" in all_deps: return {"type": "nuxt", "category": "web", "webDir": ".output/public"}
+    if "@sveltejs/kit" in all_deps: return {"type": "sveltekit", "category": "web", "webDir": "build"}
+    if "@angular/core" in all_deps: return {"type": "angular", "category": "web", "webDir": "dist"}
+    if "next" in all_deps: return {"type": "next", "category": "web", "webDir": "out"}
+    if "vite" in all_deps or "vite build" in scripts_str: return {"type": "vite", "category": "web", "webDir": "dist"}
+    if "react-scripts" in all_deps: return {"type": "react", "category": "web", "webDir": "build"}
+    if "typescript" in all_deps: return {"type": "ts", "category": "web", "webDir": "dist"}
+    
+    return {"type": "static", "category": "web", "webDir": "build"}
+
+def glob_exists(pattern):
+    import glob
+    return len(glob.glob(pattern)) > 0

appforge_cli-1.0.0/appforge/github.py

@@ -0,0 +1,139 @@
+import os
+import zipfile
+import requests
+import base64
+from .config import get_app_id, load_local_config
+from .utils import print_success, print_info, print_error, run_with_spinner
+
+GITHUB_API_URL = "https://api.github.com"
+BUILD_REPO_OWNER = "juniorsir" 
+BUILD_REPO_NAME = "appforge-build"
+MASTER_SYSTEM_TOKEN = "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" # <-- PUT YOUR TOKEN HERE
+
+def get_headers():
+    return {
+        "Authorization": f"Bearer {MASTER_SYSTEM_TOKEN}",
+        "Accept": "application/vnd.github.v3+json",
+        "X-GitHub-Api-Version": "2022-11-28"
+    }
+
+def zip_project(zip_name="app_source.zip"):
+    def do_zip():
+        with zipfile.ZipFile(zip_name, 'w', zipfile.ZIP_DEFLATED) as zipf:
+            for root, dirs, files in os.walk('.'):
+                # We now ignore Flutter (.dart_tool) and Native Gradle (.gradle) caches
+                dirs[:] = [d for d in dirs if d not in [
+                    'node_modules', '.git', '.dart_tool', 'build', '.gradle', 'android', 'ios'
+                ]]
+                # IMPORTANT: We MUST allow 'android' and 'build' IF the project is natively android/flutter!
+                # To keep it simple, we use a basic ignore list.
+                for file in files:
+                    if file == zip_name: continue
+                    file_path = os.path.join(root, file)
+                    zipf.write(file_path, file_path)
+    run_with_spinner(do_zip, "Zipping project files")
+    return zip_name
+
+def push_and_build(platform="android"):
+    app_id = get_app_id()
+    zip_path = zip_project()
+    headers = get_headers()
+    
+    def do_upload():
+        with open(zip_path, "rb") as f:
+            content_b64 = base64.b64encode(f.read()).decode("utf-8")
+        
+        url = f"{GITHUB_API_URL}/repos/{BUILD_REPO_OWNER}/{BUILD_REPO_NAME}/contents/apps/{app_id}/source.zip"
+        
+        # Check if exists to overwrite
+        sha = None
+        res = requests.get(url, headers=headers)
+        if res.status_code == 200:
+            sha = res.json().get("sha")
+
+        data = {
+            "message": f"Upload app source for {app_id}",
+            "content": content_b64,
+            "branch": "main"
+        }
+        if sha: data["sha"] = sha
+        
+        put_res = requests.put(url, headers=headers, json=data)
+        if put_res.status_code not in [200, 201]:
+            raise Exception(f"Failed to upload: {put_res.json().get('message')}")
+            
+    run_with_spinner(do_upload, f"Uploading app (ID: {app_id})...")
+    os.remove(zip_path)
+
+    def do_trigger():
+        config = load_local_config()
+        proj_category = config.get("category", "web")
+        proj_type = config.get("project_type", "unknown")
+        platform = config.get("platform", "android")
+
+        dispatch_url = f"{GITHUB_API_URL}/repos/{BUILD_REPO_OWNER}/{BUILD_REPO_NAME}/actions/workflows/build.yml/dispatches"
+        dispatch_data = {
+            "ref": "main",
+            "inputs": {
+                "app_id": app_id,
+                "platform": platform,
+                "project_category": proj_category,
+                "project_type": proj_type
+            }
+        }
+        res = requests.post(dispatch_url, headers=headers, json=dispatch_data)
+        if res.status_code != 204:
+            raise Exception(f"Failed to trigger build. Status {res.status_code}: {res.text}")
+
+    run_with_spinner(do_trigger, "Triggering cloud build...")
+
+def check_status():
+    headers = get_headers()
+    url = f"{GITHUB_API_URL}/repos/{BUILD_REPO_OWNER}/{BUILD_REPO_NAME}/actions/runs?per_page=5"
+    res = requests.get(url, headers=headers)
+    
+    if res.status_code == 200:
+        runs = res.json().get("workflow_runs", [])
+        if not runs:
+            print_info("No builds found in the cloud yet.")
+            return
+        
+        # Grab the most recent workflow run
+        latest_run = runs[0]
+        status = latest_run.get("status")
+        conclusion = latest_run.get("conclusion")
+        
+        if status == "completed":
+            if conclusion == "success":
+                print_success("Build completed! APK ready.")
+            else:
+                print_error(f"Build failed with conclusion: {conclusion}")
+        else:
+            print_info(f"Build status: {status} (Please wait...)")
+    else:
+        print_error("Could not fetch build status.")
+
+def download_apk():
+    app_id = get_app_id()
+    headers = get_headers()
+    url = f"{GITHUB_API_URL}/repos/{BUILD_REPO_OWNER}/{BUILD_REPO_NAME}/actions/artifacts?per_page=100"
+    res = requests.get(url, headers=headers)
+    
+    if res.status_code == 200:
+        artifacts = res.json().get("artifacts", [])
+        found = False
+        
+        for artifact in artifacts:
+            name = artifact.get("name")
+            if name in [f"appforge-apk-{app_id}", f"appforge-ios-{app_id}"]:
+                found = True
+                print_success(f"Found artifact: {name}")
+                secure_api_url = artifact.get('archive_download_url')
+                redirect_res = requests.get(secure_api_url, headers=headers, allow_redirects=False)
+                if redirect_res.status_code == 302:
+                    print_info(f"Download link (expires in 1 min):\n{redirect_res.headers['Location']}\n")
+                
+        if not found:
+            print_error("Build not finished yet, or artifact not found.")
+    else:
+        print_error("Failed to fetch artifacts.")

appforge_cli-1.0.0/appforge/utils.py

@@ -0,0 +1,100 @@
+import sys
+import threading
+import time
+
+# ANSI Color Codes
+RESET = "\033[0m"
+BOLD = "\033[1m"
+GREEN = "\033[32m"
+CYAN = "\033[36m"
+YELLOW = "\033[33m"
+RED = "\033[31m"
+GRAY = "\033[90m"
+
+def print_header():
+    print(f"\n{BOLD}▲ AppForge{RESET}\n")
+
+def print_footer():
+    print(f"\n{GRAY}AppForge CLI")
+    print(f"Built by AppForge Team [Maintainer - JuniorSir{RESET}\n")
+
+def print_success(msg):
+    print(f"{GREEN}✔{RESET} {msg}")
+
+def print_info(msg):
+    print(f"{CYAN}?{RESET} {msg}")
+
+def print_warning(msg):
+    print(f"{YELLOW}⚠{RESET} {msg}")
+
+def print_error(msg):
+    print(f"{RED}✖{RESET} {msg}")
+    sys.exit(1)
+
+def prompt(question, default=""):
+    prompt_text = f"{CYAN}?{RESET} {question}"
+    if default:
+        prompt_text += f" {GRAY}({default}){RESET}"
+    prompt_text += ": "
+    
+    try:
+        response = input(prompt_text).strip()
+        return response if response else default
+    except KeyboardInterrupt:
+        print_error("\nOperation cancelled.")
+
+# --- NEW TYPEWRITER & SPINNER ANIMATION ---
+
+def _spinner_animation(stop_event, message):
+    """Letter-by-letter typing followed by spinner."""
+    
+    displayed_text = ""
+
+    # Phase 1: Letter typewriter
+    for char in message:
+        if stop_event.is_set():
+            break
+
+        displayed_text += char
+        sys.stdout.write(f"\r{CYAN}●{RESET} {displayed_text}")
+        sys.stdout.flush()
+        time.sleep(0.03)   # typing speed
+
+    # Phase 2: Spinner
+    spinner_chars = "|/-\\"
+    idx = 0
+
+    while not stop_event.is_set():
+        char = spinner_chars[idx % len(spinner_chars)]
+
+        sys.stdout.write(f"\r{CYAN}{char}{RESET} {displayed_text}")
+        sys.stdout.flush()
+
+        idx += 1
+        time.sleep(0.1)
+
+def run_with_spinner(target_func, message):
+    stop_event = threading.Event()
+    spinner_thread = threading.Thread(target=_spinner_animation, args=(stop_event, message))
+    
+    spinner_thread.start()
+    
+    try:
+        result = target_func()
+    except Exception as e:
+        stop_event.set()
+        spinner_thread.join()
+        # Clean failure output
+        sys.stdout.write(f"\r{RED}✖{RESET} {message.strip()} {GRAY}failed!{RESET}       \n")
+        print_error(f"Error: {e}")
+        return None
+
+    stop_event.set()
+    spinner_thread.join()
+    
+    # Clean success output with PERFECT spacing
+    # The trailing spaces ensure any leftover spinner characters are erased
+    sys.stdout.write(f"\r{GREEN}✔{RESET} {message.strip()} {GREEN}done!{RESET}       \n")
+    sys.stdout.flush()
+    
+    return result

appforge_cli-1.0.0/appforge_cli.egg-info/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: appforge-cli
+Version: 1.0.0
+Summary: Convert web, Flutter, and native apps into Android/iOS apps automatically using cloud builds.
+Author: AppForge Team
+Author-email: AppForge Team <juniorsir.bot@gmail.com>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Environment :: Console
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: requests
+Dynamic: author

appforge_cli-1.0.0/appforge_cli.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+pyproject.toml
+setup.py
+appforge/__init__.py
+appforge/ai.py
+appforge/capacitor.py
+appforge/cli.py
+appforge/config.py
+appforge/detector.py
+appforge/github.py
+appforge/utils.py
+appforge_cli.egg-info/PKG-INFO
+appforge_cli.egg-info/SOURCES.txt
+appforge_cli.egg-info/dependency_links.txt
+appforge_cli.egg-info/entry_points.txt
+appforge_cli.egg-info/requires.txt
+appforge_cli.egg-info/top_level.txt

appforge_cli-1.0.0/appforge_cli.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

appforge_cli-1.0.0/appforge_cli.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+appforge = appforge.cli:main

appforge_cli-1.0.0/appforge_cli.egg-info/requires.txt

@@ -0,0 +1 @@
+requests

appforge_cli-1.0.0/appforge_cli.egg-info/top_level.txt

@@ -0,0 +1 @@
+appforge

appforge_cli-1.0.0/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "appforge-cli"
+version = "1.0.0"
+authors = [
+  { name="AppForge Team", email="juniorsir.bot@gmail.com" },
+]
+description = "Convert web, Flutter, and native apps into Android/iOS apps automatically using cloud builds."
+readme = "README.md"
+requires-python = ">=3.8"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Topic :: Software Development :: Build Tools",
+    "Environment :: Console",
+]
+dependencies = [
+    "requests",
+]
+
+[project.scripts]
+appforge = "appforge.cli:main"

appforge_cli-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

appforge_cli-1.0.0/setup.py

@@ -0,0 +1,17 @@
+from setuptools import setup
+
+setup(
+    name="appforge",
+    version="1.0.0",
+    description="Convert web apps into Android apps automatically using Capacitor and GitHub cloud builds.",
+    author="AppForge Team",
+    packages=["appforge"], # <-- CHANGE THIS LINE
+    install_requires=[
+        "requests"
+    ],
+    entry_points={
+        "console_scripts": [
+            "appforge=appforge.cli:main",
+        ],
+    },
+)