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

appforge_cli-1.6.0/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: appforge-cli
+Version: 1.6.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
+Requires-Dist: packaging
+Dynamic: author

{appforge_cli-1.2.4 → appforge_cli-1.6.0}/appforge/ai.py

@@ -1,69 +1,66 @@
 import os
 import json
-import re # <-- Import the Regular Expression module
+import re
 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:
+        # __file__ gives the path to the current python script (ai.py)
         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:
+        # Note: print_error must be imported from utils
         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.
+    Flutter pubspec.yaml files and scans web directories like 'www'.
     """
     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']]
-        
+        # FIXED: Removed 'www' from the ignore list so your HTML files are scanned!
+        dirs[:] = [d for d in dirs if d not in ['node_modules', '.git', 'android', 'ios', 'dist', 'build', '.next', '.nuxt', '.dart_tool']]
+
         for file in files:
             file_path = os.path.join(root, file)
 
-            # --- FLUTTER SCANNER (Now with Regex!) ---
+            # --- FLUTTER SCANNER ---
             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)
-                                
+
+                                # FIXED: Using fr"" (Raw F-String) to stop the SyntaxWarning
+                                pattern = re.compile(fr"^\s*{re.escape(package_name)}:", re.MULTILINE)
+
                                 if pattern.search(content):
                                     found_plugins[data["plugin"]] = data
-                                # ----------------------------
-                                    
-                    pubspec_already_scanned = True 
+
+                    pubspec_already_scanned = True
                 except Exception:
                     pass
 
-            # --- WEB SCANNER (un-changed) ---
+            # --- WEB SCANNER (index.html, etc.) ---
             elif file.endswith(('.js', '.ts', '.jsx', '.tsx', '.vue', '.svelte', '.html')):
                 try:
                     with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
@@ -74,5 +71,5 @@ def scan_codebase_for_permissions():
                                     found_plugins[data["plugin"]] = data
                 except Exception:
                     pass
-                    
+
     return found_plugins

{appforge_cli-1.2.4 → appforge_cli-1.6.0}/appforge/capacitor.py

@@ -35,6 +35,24 @@ def generate_capacitor_config(app_name, package_id, web_dir):
     with open("capacitor.config.json", "w") as f:
         json.dump(config, f, indent=2)
 
+def check_npm_installed():
+    """Verifies that npm is installed before attempting Capacitor setup."""
+    try:
+        # We use 'npm -v' to check if the command exists and is executable
+        subprocess.run(['npm', '-v'], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=True)
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        print_error(
+            "Node.js and npm are required to initialize Web/Capacitor projects, but they are not installed!\n\n"
+            "💡 How to fix:\n"
+            "   If you are on Termux (Android), run:\n"
+            "   pkg install nodejs\n\n"
+            "   If you are on Ubuntu/Debian, run:\n"
+            "   sudo apt install nodejs npm\n\n"
+            "   If you are on Mac, use Homebrew:\n"
+            "   brew install node\n\n"
+            "After installing, run 'appforge init' again."
+        )
+
 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")

{appforge_cli-1.2.4 → appforge_cli-1.6.0}/appforge/cli.py

@@ -1,8 +1,9 @@
 import os
 import sys
 import argparse
+import shutil
 from .utils import (print_header, print_footer, print_info, print_success, prompt, print_error, print_warning,
-                    GRAY, RESET, BOLD, CYAN, YELLOW, GREEN, RED,
+                    GRAY, RESET, BOLD, CYAN, YELLOW, GREEN, RED, CLI_VERSION, BLUE,
                     cursor_up, clear_from_cursor)
 from .detector import detect_project
 from .capacitor import setup_capacitor, apply_configuration
@@ -17,54 +18,81 @@ def init_project():
     project_info = detect_project()
     category = project_info.get("category", "web")
     proj_type = project_info.get("type", "unknown")
-    
+    default_icon_dest = os.path.join(os.getcwd(), "appforge_icon.png")
+
+    current_config = load_local_config()
+    if not current_config.get("iconPath") or not os.path.exists(current_config.get("iconPath")):
+        try:
+            cli_dir = os.path.dirname(os.path.abspath(__file__))
+            bundled_icon = os.path.join(cli_dir, "default_icon.png")
+
+            if os.path.exists(bundled_icon):
+                shutil.copy2(bundled_icon, default_icon_dest)
+                save_local_config({"iconPath": default_icon_dest})
+                print_info("Installed default AppForge app icon.")
+        except Exception as e:
+            pass
+
     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"]
-        
+        platform_choice = prompt("Select platforms (android, ios, both)", "android").lower()
+        if platform_choice == "both" or platform_choice == "all": 
+            platforms = ["android", "ios"]
+            platform_choice = "android,ios"
+        elif "ios" in platform_choice: 
+            platforms = ["ios"]
+            platform_choice = "ios"
+        else: 
+            platforms = ["android"]
+            platform_choice = "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()
+        
+        if proj_type == "flutter":
+            platform_choice = prompt("Select platforms (e.g., android, ios, windows, linux, or 'all')", "android").lower()
+            if platform_choice == "all" or platform_choice == "both":
+                platform_choice = "android,ios,windows,linux"
+        else:
+            platform_choice = prompt("Select platform to build in cloud (android)", "android").lower()
+            platform_choice = "android"
+        
         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
+        git_root = subprocess.check_output(
+            ['git', 'rev-parse', '--show-toplevel'],
+            text=True,
+            stderr=subprocess.DEVNULL
+        ).strip()
+
         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():
@@ -72,13 +100,22 @@ def configure_project():
     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", ""))
+    build_mode = prompt("Default Build Mode (debug/release)", config.get("buildMode", "debug")).lower()
+    if build_mode not in ['debug', 'release']: build_mode = 'debug'
+    current_icon = config.get("iconPath", "")
+    icon_prompt = prompt("Icon path (local PNG)", current_icon)
+    
+    # If they typed a new path, use it. Otherwise, keep the old one.
+    final_icon_path = icon_prompt if icon_prompt else current_icon
+
     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,
+        "buildMode": build_mode, 
+        "iconPath": final_icon_path,
         "iconPath": icon_path,
         "splashImg": splash_img,
         "splashBg": splash_bg
@@ -86,13 +123,15 @@ def configure_project():
     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)
+    if config.get("category") == "web":
+        apply_configuration(app_name, package_id, final_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}Default Mode:{RESET}  {config.get('buildMode', 'debug').upper()}")
     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')}")
@@ -120,7 +159,6 @@ def build_app():
         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('.')
@@ -130,6 +168,16 @@ def build_app():
         new_version_str = "1.0.1"
 
     print_info(f"Preparing build for version: {CYAN}{new_version_str}{RESET}")
+    build_type = config.get("buildMode")
+    
+    if not build_type:
+        choice = prompt("Build for Production Release? (Y/n - 'n' builds Debug)", default="y").lower()
+        build_type = "release" if choice in ['y', 'yes', ''] else "debug"
+        # Save this choice so we don't have to ask again next time
+        save_local_config({"buildMode": build_type})
+    
+    # Update the working config object
+    config['build_type'] = build_type
     config['version'] = new_version_str
 
     if config_was_updated:
@@ -139,16 +187,15 @@ def build_app():
     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")
+    print(f"  {GRAY}Next Version:{RESET}      {new_version_str}")
+    color = GREEN if build_type == "release" else YELLOW
+    print(f"  {GRAY}Build Mode:{RESET}        {color}{build_type.upper()}{RESET}\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'), 
@@ -159,11 +206,9 @@ def build_app():
                 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() 
@@ -174,8 +219,8 @@ def build_app():
         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!")
@@ -192,19 +237,14 @@ def show_history():
     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
@@ -222,23 +262,17 @@ def show_history():
 
     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
+    selected_entry = None
 
-    # 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")
         
@@ -248,7 +282,6 @@ def show_history():
         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.")
 
@@ -258,11 +291,46 @@ def status_check():
 def download_app():
     download_apk()
 
+def show_info():
+    print(f"\n{BOLD}▲ AppForge CLI Information{RESET}")
+    print("=" * 55)
+    
+    print(f"\n{CYAN}SYSTEM STATUS{RESET}")
+    print(f"  {GRAY}Current Version:{RESET} v{CLI_VERSION}")
+    print(f"  {GRAY}Cloud Target:{RESET}    Private GitHub Actions Runner")
+    print(f"  {GRAY}Connection:{RESET}      Authenticated & Active")
+    print(f"\n{CYAN}UNIVERSAL ARCHITECTURE{RESET}")
+    print(f"  {GREEN}✔{RESET} {BOLD}Web to Native{RESET} (React, Vite, Next.js, HTML)")
+    print(f"  {GREEN}✔{RESET} {BOLD}Flutter{RESET} (Full Native Compilation)")
+    print(f"  {GREEN}✔{RESET} {BOLD}Kotlin/Java{RESET} (Standard Android Studio Projects)")
+    print(f"  {GREEN}✔{RESET} {BOLD}Monorepo Support{RESET} (Sub-directory execution)")
+
+    print(f"\n{CYAN}ADVANCED FEATURES{RESET}")
+    print(f"  {YELLOW}✦{RESET} {BOLD}AI Permission Scanner:{RESET} Automatically detects required")
+    print(f"    hardware (Camera, GPS, Bluetooth) from source code.")
+    print(f"  {YELLOW}✦{RESET} {BOLD}Cloud Injector Engine:{RESET} Dynamically writes strict")
+    print(f"    Android 13+ permissions and Java 8 Desugaring rules.")
+    print(f"  {YELLOW}✦{RESET} {BOLD}Permanent Keystore:{RESET} Signs Release APKs securely via")
+    print(f"    cloud secrets to enable seamless OTA updates.")
+    print(f"  {YELLOW}✦{RESET} {BOLD}Live Telemetry:{RESET} Streams real-time GitHub Actions")
+    print(f"    build logs directly to your local terminal.")
+
+    print(f"\n{CYAN}LATEST RELEASE NOTES (v{CLI_VERSION}){RESET}")
+    print("  • Added Native App Icon & Splash Screen generation.")
+    print("  • Added intelligent 'history' command with live statuses.")
+    print("  • Fixed Flutter 'app_plugin_loader' compatibility bugs.")
+    print("  • Upgraded to robust Node.js Cloud Injection script.")
+    print("  • Added 'create' command for instant project scaffolding.")
+    
+    print("\n" + "=" * 55)
+    print(f"  {GRAY}Run 'appforge help' to see available commands.{RESET}\n")
+
 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(f"  {CYAN}info{RESET}  - View CLI version and release notes")
+    print(f"  {CYAN}create <framework> <name>{RESET} Scaffold a new app (vite, flutter, html, kotlin, win, linux), {BLUE}Ex - appforge create flutter myapp{RESET}")
     print("  appforge build      - Package project and send to build repo")
     print("  appforge status     - Check build status")
     print("  appforge download   - Download the built APK")
@@ -273,7 +341,6 @@ 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()
@@ -295,24 +362,17 @@ 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")
             
@@ -324,6 +384,7 @@ def main():
         elif args.command == "build": build_app()
         elif args.command == "configure": configure_project()
         elif args.command == "history": show_history()
+        elif args.command == "info": show_info()
         elif args.command == "status": status_check()
         elif args.command == "download": download_apk()
         else: show_help()

{appforge_cli-1.2.4 → appforge_cli-1.6.0}/appforge/create.py

@@ -4,19 +4,32 @@ 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",
+        "cmd": "git clone --progress https://github.com/flutter/samples.git _temp_samples && mv _temp_samples/provider_counter {name} && rm -rf _temp_samples",
         "desc": "Official Flutter Starter App (Native)"
     },
+    "kotlin": {
+        "cmd": "git clone --progress https://github.com/android/architecture-samples.git _temp_kt && mv _temp_kt {name} && rm -rf _temp_kt",
+        "desc": "Native Android Kotlin (Jetpack Compose)"
+    },
     "html": {
         "cmd": None,
         "desc": "Plain HTML/CSS/JS (Simple Web App)"
+    },
+    "win": {
+        "cmd": "git clone --progress https://github.com/flutter/samples.git _temp_samples",
+        "desc": "Flutter Windows Desktop App (.exe)",
+        "base_framework": "flutter" # It uses Flutter under the hood!
+    },
+    "linux": {
+        "cmd": "git clone --progress https://github.com/flutter/samples.git _temp_samples",
+        "desc": "Flutter Linux Desktop App",
+        "base_framework": "flutter" # It uses Flutter under the hood!
     }
 }