appforge-cli 1.1.4__tar.gz → 1.2.4__tar.gz

{appforge_cli-1.1.4 → appforge_cli-1.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: appforge-cli
-Version: 1.1.4
+Version: 1.2.4
 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>

appforge_cli-1.2.4/appforge/ai.py

@@ -0,0 +1,78 @@
+import os
+import json
+import re # <-- Import the Regular Expression module
+from .utils import print_info, print_success, print_error, CYAN, RESET, GRAY
+
+def load_knowledge_base():
+    """Loads the AI keyword-to-plugin mappings from the JSON file."""
+    try:
+        current_dir = os.path.dirname(os.path.abspath(__file__))
+        json_path = os.path.join(current_dir, 'knowledge_base.json')
+        with open(json_path, 'r') as f:
+            return json.load(f)
+    except Exception as e:
+        print_error(f"Critical Error: Could not load AI knowledge base: {e}")
+        return {}
+
+def scan_codebase_for_permissions():
+    """
+    Universally scans project files. It now uses regex to robustly parse
+    Flutter pubspec.yaml files, ignoring indentation differences.
+    """
+    ai_knowledge_base = load_knowledge_base()
+    
+    print_info(f"{CYAN}🤖 AI Agent scanning codebase for native features...{RESET}")
+    
+    found_plugins = {}
+    pubspec_already_scanned = False
+    
+    for root, dirs, files in os.walk('.'):
+        dirs[:] = [d for d in dirs if d not in ['node_modules', '.git', 'android', 'ios', 'dist', 'build', '.next', '.nuxt', 'www', '.dart_tool']]
+        
+        for file in files:
+            file_path = os.path.join(root, file)
+
+            # --- FLUTTER SCANNER (Now with Regex!) ---
+            if file == 'pubspec.yaml' and not pubspec_already_scanned:
+                try:
+                    with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
+                        content = f.read()
+                        
+                        if 'workspace:' in content:
+                            print_info(f"Ignoring Flutter workspace file: {GRAY}{file_path}{RESET}")
+                            continue
+                        
+                        print_info(f"Analyzing dependencies in {GRAY}{file_path}{RESET}")
+                        for keyword, data in ai_knowledge_base.items():
+                            if keyword.startswith("pubspec:"):
+                                package_name = keyword.split(":")[1]
+                                
+                                # --- THIS IS THE REGEX FIX ---
+                                # This pattern looks for:
+                                # ^      - start of a line
+                                # \s*    - any amount of whitespace (spaces, tabs)
+                                # {name} - the package name
+                                # :      - a colon
+                                pattern = re.compile(f"^\s*{re.escape(package_name)}:", re.MULTILINE)
+                                
+                                if pattern.search(content):
+                                    found_plugins[data["plugin"]] = data
+                                # ----------------------------
+                                    
+                    pubspec_already_scanned = True 
+                except Exception:
+                    pass
+
+            # --- WEB SCANNER (un-changed) ---
+            elif file.endswith(('.js', '.ts', '.jsx', '.tsx', '.vue', '.svelte', '.html')):
+                try:
+                    with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
+                        content = f.read()
+                        for keyword, data in ai_knowledge_base.items():
+                            if not keyword.startswith("pubspec:"):
+                                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.1.4 → appforge_cli-1.2.4}/appforge/capacitor.py

@@ -6,10 +6,20 @@ 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)
+        if hide_output:
+            # Capture both stdout and stderr to hide them unless there's an error
+            result = subprocess.run(
+                command, shell=True, check=True, capture_output=True, text=True
+            )
+        else:
+            # Stream output directly to terminal
+            subprocess.run(command, shell=True, check=True)
     except subprocess.CalledProcessError as e:
-        error_message = f"Command '{command}' failed. Please check your setup."
+        # If the command fails, print the actual error from the command!
+        error_message = f"Command '{command}' failed."
+        # The real error from npm/git/etc. will be in stderr
+        if e.stderr:
+            error_message += f"\n\n--- Error Details ---\n{e.stderr.strip()}\n---------------------"
         print_error(error_message)
 
 

appforge_cli-1.2.4/appforge/cli.py

@@ -0,0 +1,334 @@
+import os
+import sys
+import argparse
+from .utils import (print_header, print_footer, print_info, print_success, prompt, print_error, print_warning,
+                    GRAY, RESET, BOLD, CYAN, YELLOW, GREEN, RED,
+                    cursor_up, clear_from_cursor)
+from .detector import detect_project
+from .capacitor import setup_capacitor, apply_configuration
+from .config import save_local_config, load_local_config, load_history, get_app_id
+from .github import push_and_build, check_status as check_by_id, download_apk as download_by_id, check_status, download_apk, get_build_status_by_id
+import time
+from .ai import scan_codebase_for_permissions
+from .capacitor import install_plugins
+from .create import create_project
+
+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)
+    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})
+
+    # --- UNIVERSAL AI PERMISSION SYSTEM ---
+    print("")
+    # Pass the category to the AI!
+    detected_features = scan_codebase_for_permissions()
+    
+    if detected_features:
+        print_success(f"AI detected {len(detected_features)} native features required by your app:")
+        
+        for data in detected_features.values():
+            print(f"  {CYAN}●{RESET} {data['feature']} {GRAY}({data['desc']}){RESET}")
+            
+        print_info("The AppForge Cloud Server will automatically inject these permissions during the build process.")
+    else:
+        print_info("AI scan complete. No special native permissions detected.")
+    # --------------------------------------
+    try:
+        import subprocess
+        # Find the top-level directory of the git repo
+        git_root = subprocess.check_output(['git', 'rev-parse', '--show-toplevel'], text=True).strip()
+        
+        # Get the relative path from the git root to the current directory
+        sub_path = os.path.relpath(os.getcwd(), git_root)
+        
+        # If we are in a sub-directory, save it
+        if sub_path and sub_path != '.':
+            print_info(f"Detected sub-project path: {GRAY}{sub_path}{RESET}")
+            save_local_config({"sub_path": sub_path})
+            
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        # Not a git repo, or git not installed. Assume it's a standalone project.
+        save_local_config({"sub_path": "."})
+    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
+
+    # --- VERSION INCREMENT LOGIC ---
+    current_version_str = config.get("version", "1.0.0")
+    try:
+        parts = current_version_str.split('.')
+        parts[-1] = str(int(parts[-1]) + 1)
+        new_version_str = '.'.join(parts)
+    except:
+        new_version_str = "1.0.1"
+
+    print_info(f"Preparing build for version: {CYAN}{new_version_str}{RESET}")
+    config['version'] = new_version_str
+
+    if config_was_updated:
+        save_local_config(config)
+        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')}")
+    print(f"  {GRAY}Next Version:{RESET}      {new_version_str}\n")
+
+    # Ask ONLY ONCE if they want to build
+    action = prompt("Proceed with build? (Y/n)", default="y").lower()
+
+    if action in ['y', 'yes', '']:
+        # 1. Save new version to local memory
+        save_local_config({"version": new_version_str})
+        
+        # 2. Sync CLI memory to Capacitor native config
+        if config.get("category") == "web":
+            apply_configuration(
+                config.get('appName', 'My App'), 
+                config.get('packageId', 'com.example.app'), 
+                config.get('iconPath'),
+                config.get('splashImg'), 
+                config.get('splashBg'), 
+                config.get('webDir', 'dist')
+            )
+
+        # 3. Zip and send to cloud
+        push_and_build(config)
+        print_success("Your app is now building in the cloud!")
+        
+        # 4. Ask to watch logs
+        watch = prompt("Watch live build logs? (Y/n)", default="y").lower()
+        if watch in ['y', 'yes', '']:
+            status_check() 
+        else:
+            print_info("Run 'appforge status' later to check its progress.")
+            
+    else:
+        print(f"\n{GREEN}Run 'appforge configure' to edit App configuration{RESET}")
+        print("\n")
+        print_info("Build cancelled.")
+def show_history():
+    """Displays a list of past builds with their current cloud status."""
+    history = load_history()
+    if not history:
+        print_info("No build history found. Run 'appforge build' to create your first app!")
+        return
+
+    print(f"\n{BOLD}Your Recent AppForge Builds:{RESET}")
+    print(f"  {GRAY}{'ID':<10} {'PROJECT':<20} {'PLATFORM':<10} {'TRIGGERED (UTC)':<22} {'STATUS'}{RESET}")
+    print("-" * 80)
+
+    entries_to_display = history[:10]
+    
+    print_info("Fetching latest statuses from the cloud...\n")
+
+    for entry in entries_to_display:
+        from datetime import datetime
+        
+        # Format the timestamp
+        dt_obj = datetime.fromisoformat(entry['triggered_at'].replace('Z', '+00:00'))
+        formatted_time = dt_obj.strftime('%Y-%m-%d %H:%M:%S')
+
+        # Fetch real-time status from GitHub
+        run_id = entry.get("run_id")
+        if run_id:
+            status, conclusion = get_build_status_by_id(run_id)
+        else:
+            # Fallback for old history items
+            status, conclusion = entry.get("status", "unknown"), entry.get("conclusion", None)
+        
+        # --- STATIC STATUS DISPLAY LOGIC ---
+        status_text = ""
+        if status in ["in_progress", "queued"]:
+            # Static yellow text instead of animation
+            status_text = f"{YELLOW}▶ Building...{RESET}"
+        elif status == "completed":
+            if conclusion == "success":
+                status_text = f"{GREEN}✔ Success{RESET}"
+            else:
+                status_text = f"{RED}✖ Failed{RESET}"
+        else:
+            status_text = f"{GRAY}{(status or 'Unknown').capitalize()}{RESET}"
+        
+        # Print the row
+        print(f"  {CYAN}{entry['app_id']:<9}{RESET} {entry['project_name']:<20} {entry['platform']:<10} {formatted_time:<22} {status_text}")
+
+    print("-" * 80)
+    
+    # Update the prompt text to be perfectly clear
+    choice = prompt("Enter a number or App ID to re-download, or press Enter to exit").strip().lower()
+
+    selected_entry = None # This will hold the build the user wants
+
+    # Case 1: User entered a number from the list
+    if choice.isdigit() and 0 < int(choice) <= len(entries_to_display):
+        selected_index = int(choice) - 1
+        selected_entry = entries_to_display[selected_index]
+
+    # Case 2: User entered text (could be an App ID)
+    elif choice:
+        # Find the *first* (most recent) entry in the full history that matches the ID.
+        # We use startswith so users can just type the first few characters (e.g., '9a6b').
+        selected_entry = next((entry for entry in history if entry['app_id'].lower().startswith(choice)), None)
+
+    # Now, if we found an entry by either method, proceed with the download
+    if selected_entry:
+        run_id_to_download = selected_entry.get("run_id")
+        
+        if run_id_to_download:
+            print_info(f"Fetching artifact for Build Run ID: {run_id_to_download} (App ID: {selected_entry['app_id']})")
+            download_apk(run_id=run_id_to_download)
+        else:
+            print_warning("This is a legacy build entry without a unique Run ID. Cannot guarantee the correct artifact.")
+    
+    # Case 3: User typed something, but it was invalid
+    elif choice:
+        print_warning("Invalid input. Please enter a number from the list or a valid App ID.")
+
+def status_check():
+    check_status()
+
+def download_app():
+    download_apk()
+
+def show_argu():
+    print("Commands:")
+    print("  appforge init       - Initialize an AppForge project")
+    print("  appforge configure  - Open interactive settings")
+    print(f"  {CYAN}create <framework> <name>{RESET} Scaffold a new app (vite, flutter, html)")
+    print("  appforge build      - Package project and send to build repo")
+    print("  appforge status     - Check build status")
+    print("  appforge download   - Download the built APK")
+    print(f"  {CYAN}history{RESET}     View a list of your past builds")
+    print("  appforge help       - Show this help message")
+
+def show_help():
+    """The animated welcome sequence for the very first run."""
+    welcome_message = f"{BOLD}▲ AppForge{RESET} - The 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.")
+    
+    print("\nGetting Started:")
+    print("  1. `cd` into your project directory")
+    print("  2. Run `appforge init` to begin\n")
+    
+    show_argu()
+    sys.exit(0)
+
+def main():
+    
+    print_header()
+    
+    # --- FIXED ARGPARSE LOGIC ---
+    parser = argparse.ArgumentParser(add_help=False)
+    # The first word is the command (defaulting to "help")
+    parser.add_argument("command", nargs="?", default="help", help="Command to run")
+    # All remaining words get bundled into a list called "args"
+    parser.add_argument("args", nargs=argparse.REMAINDER, help="Additional arguments")
+    
+    # parse_known_args is safer here than parse_args
+    args, unknown = parser.parse_known_args()
+    
+    # If there were extra arguments that slipped past, add them to our list
+    if unknown:
+        args.args.extend(unknown)
+    # ----------------------------
+
+    try:
+        if args.command == "create":
+            # Check if they provided the framework and name
+            if not args.args or len(args.args) < 2:
+                print_error("Usage: appforge create <framework> <project-name>\nExample: appforge create flutter my_new_app")
+            
+            framework = args.args[0].lower()
+            project_name = args.args[1]
+            create_project(framework, project_name)
+            
+        elif args.command == "init": init_project()
+        elif args.command == "build": build_app()
+        elif args.command == "configure": configure_project()
+        elif args.command == "history": show_history()
+        elif args.command == "status": status_check()
+        elif args.command == "download": download_apk()
+        else: show_help()
+    finally:
+        print_footer()
+
+if __name__ == "__main__":
+    main()

appforge_cli-1.2.4/appforge/config.py

@@ -0,0 +1,52 @@
+import os
+import json
+import uuid
+from .utils import print_error
+
+LOCAL_CONFIG_FILE = ".appforge.json"
+HISTORY_FILE = os.path.expanduser("~/.appforge_history.json")
+
+def load_history():
+    """Loads the global build history from the user's home directory."""
+    if not os.path.exists(HISTORY_FILE):
+        return []
+    try:
+        with open(HISTORY_FILE, "r") as f:
+            return json.load(f)
+    except (json.JSONDecodeError, FileNotFoundError):
+        return []
+
+def save_history(history_data):
+    """Saves the global build history."""
+    with open(HISTORY_FILE, "w") as f:
+        json.dump(history_data, f, indent=2)
+
+def add_to_history(new_build_entry):
+    """Adds a new build record to the history."""
+    history = load_history()
+    # Prepend the new entry to the top of the list
+    history.insert(0, new_build_entry)
+    # Keep the history from getting too long (e.g., max 50 entries)
+    if len(history) > 50:
+        history = history[:50]
+    save_history(history)
+
+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"]

appforge_cli-1.2.4/appforge/create.py

@@ -0,0 +1,93 @@
+import os
+import shutil
+import subprocess
+import re
+from .utils import print_success, print_info, print_error, prompt, print_progress_bar, CYAN, RESET, BOLD
+
+# The TEMPLATES dictionary stays the same
+TEMPLATES = {
+    "vite": {
+        "cmd": "npm create vite@latest {name} -- --template react-ts",
+        "desc": "React + TypeScript + Vite (Fast Web App)"
+    },
+    "flutter": {
+        "cmd": "git clone --progress https://github.com/flutter/samples.git _temp_samples",
+        "desc": "Official Flutter Starter App (Native)"
+    },
+    "html": {
+        "cmd": None,
+        "desc": "Plain HTML/CSS/JS (Simple Web App)"
+    }
+}
+
+def generate_html_template(project_name):
+    # This function stays exactly the same
+    os.makedirs(project_name, exist_ok=True)
+    os.makedirs(os.path.join(project_name, "www"), exist_ok=True)
+    html_content = f"""...""" # Keep your HTML content
+    with open(os.path.join(project_name, "www", "index.html"), "w") as f:
+        f.write(html_content)
+
+def create_project(framework, project_name):
+    """Generates a new project with a real progress bar for git clone."""
+    if framework not in TEMPLATES:
+        print_error(f"Unknown framework: {framework}.")
+
+    if os.path.exists(project_name):
+        print_error(f"Directory '{project_name}' already exists.")
+
+    template = TEMPLATES[framework]
+    print_info(f"Creating a new {BOLD}{template['desc']}{RESET} project in {CYAN}./{project_name}{RESET}...")
+    
+    if framework == "html":
+        generate_html_template(project_name)
+    else:
+        # --- NEW REAL-TIME PROGRESS BAR LOGIC ---
+        cmd = template["cmd"].format(name=project_name)
+        
+        try:
+            # We open a subprocess and read its stderr line by line
+            process = subprocess.Popen(
+                cmd,
+                shell=True,
+                stderr=subprocess.PIPE,
+                stdout=subprocess.DEVNULL, # Hide normal git output
+                text=True,
+                bufsize=1 # Line-buffered
+            )
+
+            # Regex to find the percentage in git's output
+            # It looks for "Receiving objects:  25%"
+            progress_regex = re.compile(r"(\d+)%")
+            
+            # Read each line of output from the running git command
+            for line in iter(process.stderr.readline, ''):
+                match = progress_regex.search(line)
+                if match:
+                    percentage = float(match.group(1))
+                    print_progress_bar(percentage, f"Downloading {framework} template")
+            
+            process.wait() # Wait for the command to finish
+            if process.returncode != 0:
+                raise Exception("Git clone failed.")
+
+            print_progress_bar(100.0, f"Downloading {framework} template")
+            
+            # Post-clone cleanup for Flutter
+            if framework == "flutter":
+                shutil.move("_temp_samples/provider_counter", project_name)
+                shutil.rmtree("_temp_samples", ignore_errors=True)
+                shutil.rmtree(os.path.join(project_name, ".git"), ignore_errors=True)
+
+        except Exception as e:
+            # Clean up partial downloads on failure
+            if os.path.exists("_temp_samples"):
+                shutil.rmtree("_temp_samples", ignore_errors=True)
+            print_error(f"Project creation failed: {e}")
+        # --- END OF NEW LOGIC ---
+
+    print_success(f"Project '{project_name}' created successfully!")
+    print("\nNext steps:")
+    print(f"  {CYAN}cd {project_name}{RESET}")
+    print(f"  {CYAN}appforge init{RESET}")
+    print("")