pysfi 0.1.7__py3-none-any.whl → 0.1.11__py3-none-any.whl

sfi/pyloadergen/pyloadergen.py

@@ -6,8 +6,11 @@ import platform
 import shutil
 import subprocess
 import time
+from dataclasses import dataclass
 from pathlib import Path
 
+from sfi.pyprojectparse.pyprojectparse import Project
+
 is_windows = platform.system() == "Windows"
 is_linux = platform.system() == "Linux"
 is_macos = platform.system() == "Darwin"
@@ -17,6 +20,44 @@ logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
 logger = logging.getLogger(__name__)
 cwd = Path.cwd()
 
+
+@dataclass(frozen=True)
+class CompilerConfig:
+    """Compiler configuration dataclass.
+
+    Attributes:
+        name: Compiler name
+        args: List of compiler arguments
+    """
+
+    name: str
+    args: tuple[str, ...]
+
+    def to_list(self) -> list[str]:
+        """Convert arguments to list.
+
+        Returns:
+            List of compiler arguments
+        """
+        return list(self.args)
+
+
+@dataclass(frozen=True)
+class EntryFile:
+    """Entry file dataclass."""
+
+    project_name: str
+    source_file: Path
+
+    @property
+    def entry_name(self) -> str:
+        """Get entry file name."""
+        return self.source_file.stem
+
+    def __repr__(self) -> str:
+        return f"<EntryFile project_name={self.project_name} source_file={self.source_file}>"
+
+
 _WINDOWS_GUI_TEMPLATE: str = r"""#include <windows.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -36,32 +77,24 @@ static void build_python_command(
     char* cmd,
     const char* exe_dir,
     const char* entry_file,
-    int is_debug
+    int is_debug,
+    LPSTR lpCmdLine
 ) {
     char python_runtime[MAX_PATH_LEN];
     char script_path[MAX_PATH_LEN];
 
     // Build Python interpreter path
-    // GUI non-debug mode uses pythonw.exe (no console), other cases use python.exe
-    if (is_debug) {
-        // Debug mode: use python.exe to show console output
-        snprintf(python_runtime, MAX_PATH_LEN, "%s\\runtime\\python.exe", exe_dir);
-    } else {
-        // Production GUI mode: use pythonw.exe without creating console window
-        snprintf(python_runtime, MAX_PATH_LEN, "%s\\runtime\\pythonw.exe", exe_dir);
-    }
+    snprintf(python_runtime, MAX_PATH_LEN, "%s\\runtime\\%s", exe_dir, is_debug ? "python.exe" : "pythonw.exe");
 
     // Build startup script path
     snprintf(script_path, MAX_PATH_LEN, "%s\\%s", exe_dir, entry_file);
 
-    // Build command line (add -u parameter for real-time output capture)
-    if (is_debug) {
-        // Debug mode: do not redirect output, display output on console
-        snprintf(cmd, MAX_PATH_LEN, "\"%s\" -u \"%s\"", python_runtime, script_path);
-    } else {
-        // Production mode: redirect all output to pipe
-        snprintf(cmd, MAX_PATH_LEN, "\"%s\" -u \"%s\" 2>&1", python_runtime, script_path);
-    }
+    // Build command line: python runtime -u script [args] [2>&1 for production]
+    snprintf(cmd, MAX_PATH_LEN * 2, "\"%s\" -u \"%s\"%s%s%s",
+        python_runtime, script_path,
+        lpCmdLine && strlen(lpCmdLine) > 0 ? " " : "",
+        lpCmdLine && strlen(lpCmdLine) > 0 ? lpCmdLine : "",
+        is_debug ? "" : " 2>&1");
 }
 
 // Read process output
@@ -69,7 +102,8 @@ static void read_process_output(HANDLE hPipe, char* output, int max_len) {
     DWORD bytes_read;
     output[0] = '\0';
 
-    while (ReadFile(hPipe, output + strlen(output), max_len - strlen(output) - 1, &bytes_read, NULL) && bytes_read > 0) {
+    while (
+    ReadFile(hPipe, output + strlen(output), max_len - strlen(output) - 1, &bytes_read, NULL) && bytes_read > 0) {
         output[bytes_read] = '\0';
     }
 }
@@ -108,6 +142,7 @@ int APIENTRY WinMain(
     char exe_dir[MAX_PATH_LEN];
     char cmd[MAX_PATH_LEN * 2];
     char error_output[MAX_ERROR_LEN] = "";
+    char error_msg[MAX_ERROR_LEN];
     STARTUPINFOA si = {0};
     PROCESS_INFORMATION pi = {0};
     SECURITY_ATTRIBUTES sa = {0};
@@ -131,33 +166,28 @@ int APIENTRY WinMain(
         return 1;
     }
 
-    // Build and execute Python command
-    build_python_command(cmd, exe_dir, "${ENTRY_FILE}", ${DEBUG_MODE});
-
-    // Create pipe for capturing output
-    sa.nLength = sizeof(SECURITY_ATTRIBUTES);
-    sa.bInheritHandle = TRUE;
-    sa.lpSecurityDescriptor = NULL;
-
-    if (!CreatePipe(&hReadPipe, &hWritePipe, &sa, 0)) {
-        show_message_box("Error", "Failed to create pipe for error output.");
-        return 1;
-    }
+    // Create pipe for capturing output (only in production mode)
+    if (!${DEBUG_MODE}) {
+        sa.nLength = sizeof(SECURITY_ATTRIBUTES);
+        sa.bInheritHandle = TRUE;
+        sa.lpSecurityDescriptor = NULL;
 
-    // Set startup info
-    si.cb = sizeof(si);
+        if (!CreatePipe(&hReadPipe, &hWritePipe, &sa, 0)) {
+            show_message_box("Error", "Failed to create pipe for error output.");
+            return 1;
+        }
 
-    // Set different startup methods based on debug mode
-    if (${DEBUG_MODE}) {
-        // Debug mode: do not use pipe, inherit console to display output
-        // Keep si.dwFlags as 0, do not set STARTF_USESTDHANDLES
-    } else {
-        // Production GUI mode: use pipe to capture error output
+        si.cb = sizeof(si);
         si.dwFlags = STARTF_USESTDHANDLES;
         si.hStdError = hWritePipe;
         si.hStdOutput = hWritePipe;
+    } else {
+        si.cb = sizeof(si);
     }
 
+    // Build and execute Python command
+    build_python_command(cmd, exe_dir, "${ENTRY_FILE}", ${DEBUG_MODE}, lpCmdLine);
+
     // Create Python process
     // Debug mode: do not use CREATE_NO_WINDOW, let python.exe create console
     // Production GUI mode: use CREATE_NO_WINDOW to ensure no console is created
@@ -170,7 +200,6 @@ int APIENTRY WinMain(
 
     if (!success) {
         DWORD error = GetLastError();
-        char error_msg[MAX_ERROR_LEN];
         snprintf(error_msg, MAX_ERROR_LEN,
             "Failed to start Python process.\n\n"
             "Error code: %lu\n"
@@ -198,8 +227,9 @@ int APIENTRY WinMain(
     DWORD exit_code;
     GetExitCodeProcess(pi.hProcess, &exit_code);
 
-    // Debug output
+#if ${DEBUG_MODE}
     fprintf(stderr, "DEBUG: Python process exited with code: %lu\n", exit_code);
+#endif
 
     // Cleanup
     CloseHandle(pi.hProcess);
@@ -227,6 +257,7 @@ _WINDOWS_CONSOLE_TEMPLATE: str = r"""#include <stdio.h>
 #include <locale.h>
 
 #define MAX_PATH_LEN 4096
+#define MAX_ERROR_LEN 8192
 
 // Set console encoding to UTF-8
 static void setup_encoding() {
@@ -245,10 +276,14 @@ static void build_python_command(
     char* cmd,
     const char* exe_dir,
     const char* entry_file,
-    int debug_mode
+    int argc,
+    char* argv[]
 ) {
     char python_runtime[MAX_PATH_LEN];
     char script_path[MAX_PATH_LEN];
+    char* p = cmd;
+    size_t remaining = MAX_PATH_LEN * 2;
+    int len;
 
     // Build Python interpreter path
     snprintf(python_runtime, MAX_PATH_LEN, "%s\\runtime\\python.exe", exe_dir);
@@ -256,11 +291,27 @@ static void build_python_command(
     // Build startup script path
     snprintf(script_path, MAX_PATH_LEN, "%s\\%s", exe_dir, entry_file);
 
-    // Build command line (add -u parameter for real-time output capture)
-    if (debug_mode) {
-        snprintf(cmd, MAX_PATH_LEN, "\"%s\" \"%s\"", python_runtime, script_path);
-    } else {
-        snprintf(cmd, MAX_PATH_LEN, "\"%s\" -u \"%s\" 2>&1", python_runtime, script_path);
+    // Base command
+    len = snprintf(p, remaining, "\"%s\" -u \"%s\"", python_runtime, script_path);
+    p += len;
+    remaining -= len;
+
+    // Append arguments
+    for (int i = 1; i < argc && remaining > 0; i++) {
+        len = snprintf(p, remaining, " \"%s\"", argv[i]);
+        if (len < 0 || (size_t)len >= remaining) break;
+        p += len;
+        remaining -= len;
+    }
+}
+
+// Read process output
+static void read_process_output(HANDLE hPipe, char* output, int max_len) {
+    DWORD bytes_read;
+    output[0] = '\0';
+
+    while (ReadFile(hPipe, output + strlen(output), max_len - strlen(output) - 1, &bytes_read, NULL) && bytes_read > 0) {
+        output[bytes_read] = '\0';
     }
 }
 
@@ -270,49 +321,52 @@ int main(int argc, char* argv[]) {
     char cmd[MAX_PATH_LEN * 2];
     STARTUPINFOA si = {0};
     PROCESS_INFORMATION pi = {0};
+    BOOL success;
+    char* last_slash;
 
-    // Set encoding to UTF-8
+    // Setup
     setup_encoding();
+    si.cb = sizeof(si);
 
     // Get executable directory
     GetModuleFileNameA(NULL, exe_dir, MAX_PATH_LEN);
-    char* last_slash = strrchr(exe_dir, '\\');
-    if (last_slash) {
-        *last_slash = '\0';
-    }
-
+    if ((last_slash = strrchr(exe_dir, '\\'))) *last_slash = '\0';
+`
     // Check Python runtime
-    char python_runtime_check[MAX_PATH_LEN];
-    snprintf(python_runtime_check, MAX_PATH_LEN, "%s\\runtime\\python.exe", exe_dir);
-    if (!check_python_runtime(python_runtime_check)) {
+    if (!check_python_runtime(exe_dir)) {
         fprintf(stderr, "Error: Python runtime not found at %s\\runtime\\\n", exe_dir);
         fprintf(stderr, "Please ensure the application is installed correctly.\n");
         return 1;
     }
 
     // Build and execute Python command
-    build_python_command(cmd, exe_dir, "${ENTRY_FILE}", ${DEBUG_MODE});
+    build_python_command(cmd, exe_dir, "${ENTRY_FILE}", argc, argv);
 
+#if ${DEBUG_MODE}
     // Debug output
-    if (${DEBUG_MODE}) {
-        fprintf(stderr, "DEBUG: Command to execute: %s\n", cmd);
-        fprintf(stderr, "DEBUG: exe_dir: %s\n", exe_dir);
+#ifdef _WIN32
+    {
+        int wcmd_len = MultiByteToWideChar(CP_UTF8, 0, cmd, -1, NULL, 0);
+        if (wcmd_len > 0) {
+            wchar_t* wcmd = (wchar_t*)malloc(wcmd_len * sizeof(wchar_t));
+            MultiByteToWideChar(CP_UTF8, 0, cmd, -1, wcmd, wcmd_len);
+            fwprintf(stderr, L"DEBUG: Command to execute: %ls\n", wcmd);
+            free(wcmd);
+        }
     }
-
-    // Set startup info to inherit console
-    si.cb = sizeof(si);
-
-    // Ensure standard handles are inherited so output displays on console
-    si.dwFlags = STARTF_USESTDHANDLES;
-    si.hStdInput = GetStdHandle(STD_INPUT_HANDLE);
-    si.hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
-    si.hStdError = GetStdHandle(STD_ERROR_HANDLE);
+#else
+    fprintf(stderr, "DEBUG: Command to execute: %s\n", cmd);
+#endif
+#endif
 
     // Create Python process
-    if (!CreateProcessA(
-        NULL, cmd, NULL, NULL, TRUE,  // TRUE to inherit standard handles
+    // TRUE - inherit handles so Python can write to console
+    success = CreateProcessA(
+        NULL, cmd, NULL, NULL, TRUE,
         0, NULL, exe_dir, &si, &pi
-    )) {
+    );
+
+    if (!success) {
         DWORD error = GetLastError();
         fprintf(stderr, "Error: Failed to start Python process.\n");
         fprintf(stderr, "Error code: %lu\n", error);
@@ -320,6 +374,9 @@ int main(int argc, char* argv[]) {
         return 1;
     }
 
+    // In non-debug mode for console apps, we don't use pipes, so no error output capture
+    // All output (stdout/stderr) goes directly to console
+
     // Wait for process to end
     WaitForSingleObject(pi.hProcess, INFINITE);
 
@@ -327,19 +384,19 @@ int main(int argc, char* argv[]) {
     DWORD exit_code;
     GetExitCodeProcess(pi.hProcess, &exit_code);
 
-    // Debug output
-    if (${DEBUG_MODE}) {
-        fprintf(stderr, "DEBUG: Python process exited with code: %lu\n", exit_code);
-    }
+#if ${DEBUG_MODE}
+    fprintf(stderr, "DEBUG: Python process exited with code: %lu\n", exit_code);
+#endif
 
     // Cleanup
     CloseHandle(pi.hProcess);
     CloseHandle(pi.hThread);
 
-    // If process exits abnormally, display prompt
-    if (exit_code != 0 && !${DEBUG_MODE}) {
-        fprintf(stderr, "\nApplication exited abnormally, error code: %lu\n", exit_code);
-        fprintf(stderr, "Please check the error information above for details.\n");
+    // In non-debug mode, we don't capture output, so just report exit code if non-zero
+    if (exit_code != 0) {
+        fprintf(stderr, "\nApplication exited with error code: %lu\n", exit_code);
+        fprintf(stderr, "Check console output above for details.\n");
+        return exit_code;
     }
 
     return exit_code;
@@ -382,26 +439,23 @@ static void build_python_command(
 
 // Unix GUI entry point
 int main(int argc, char* argv[]) {
+    (void)argc;
     char exe_dir[MAX_PATH_LEN];
-    char cmd[MAX_PATH_LEN * 2];
+    char cmd[MAX_PATH_LEN * 3];
     char log_file[MAX_PATH_LEN];
     pid_t pid;
     int status;
+    char* last_slash;
 
     // Get executable directory
-    if (realpath("/proc/self/exe", exe_dir) == NULL) {
-        // If /proc/self/exe is unavailable (like on macOS), use argv[0]
-        if (realpath(argv[0], exe_dir) == NULL) {
-            fprintf(stderr, "Error: Cannot determine executable directory\n");
-            return 1;
-        }
+    if (realpath("/proc/self/exe", exe_dir) == NULL &&
+        realpath(argv[0], exe_dir) == NULL) {
+        fprintf(stderr, "Error: Cannot determine executable directory\n");
+        return 1;
     }
 
     // Remove executable name, keep only directory
-    char* last_slash = strrchr(exe_dir, '/');
-    if (last_slash) {
-        *last_slash = '\0';
-    }
+    if ((last_slash = strrchr(exe_dir, '/'))) *last_slash = '\0';
 
     // Build and execute Python command
     build_python_command(cmd, exe_dir, "${ENTRY_FILE}");
@@ -471,10 +525,13 @@ static void build_python_command(
 
 // Unix Console entry point
 int main(int argc, char* argv[]) {
+    (void)argc;
+    (void)argv;
     char exe_dir[MAX_PATH_LEN];
-    char cmd[MAX_PATH_LEN * 2];
+    char cmd[MAX_PATH_LEN * 3];
     pid_t pid;
     int status;
+    char* last_slash;
 
     // Get executable directory
     if (realpath("/proc/self/exe", exe_dir) == NULL) {
@@ -483,10 +540,7 @@ int main(int argc, char* argv[]) {
     }
 
     // Remove executable name, keep only directory
-    char* last_slash = strrchr(exe_dir, '/');
-    if (last_slash) {
-        *last_slash = '\0';
-    }
+    if ((last_slash = strrchr(exe_dir, '/'))) *last_slash = '\0';
 
     // Build and execute Python command
     build_python_command(cmd, exe_dir, "${ENTRY_FILE}");
@@ -549,8 +603,10 @@ static void get_exe_dir_macos(char* exe_dir, size_t size) {
             CFRelease(url);
         }
     } else {
-        // If not in bundle, use argv[0]
-        realpath("./", exe_dir);
+        // If not in bundle, get current working directory
+        if (getcwd(exe_dir, size) == NULL) {
+            exe_dir[0] = '\0';
+        }
     }
 
     // Remove Contents/MacOS suffix of bundle
@@ -558,10 +614,10 @@ static void get_exe_dir_macos(char* exe_dir, size_t size) {
     if (macos_path) {
         *macos_path = '\0';
     }
-    }
+}
 
-    // Display macOS error dialog
-    static void show_error_dialog(const char* message) {
+// Display macOS error dialog
+static void show_error_dialog(const char* message) {
     CFStringRef cf_message = CFStringCreateWithCString(
         NULL, message, kCFStringEncodingUTF8
     );
@@ -603,9 +659,12 @@ static void build_python_command(
 
 // macOS GUI entry point
 int main(int argc, char* argv[]) {
+    (void)argc;
+    (void)argv;
     char exe_dir[MAX_PATH_LEN];
-    char cmd[MAX_PATH_LEN * 2];
+    char cmd[MAX_PATH_LEN * 3];
     char log_file[MAX_PATH_LEN];
+    char python_runtime[MAX_PATH_LEN];
     pid_t pid;
     int status;
 
@@ -613,10 +672,8 @@ int main(int argc, char* argv[]) {
     get_exe_dir_macos(exe_dir, MAX_PATH_LEN);
 
     // Check Python runtime
-    char python_runtime[MAX_PATH_LEN];
     snprintf(python_runtime, MAX_PATH_LEN, "%s/runtime/bin/python3", exe_dir);
     if (!check_python_runtime(python_runtime)) {
-        // macOS GUI app needs to use dialog to display error
         char error_msg[MAX_PATH_LEN];
         snprintf(error_msg, MAX_PATH_LEN,
             "Python runtime not found.\n\n"
@@ -704,7 +761,10 @@ static void get_exe_dir_macos(char* exe_dir, size_t size) {
             CFRelease(url);
         }
     } else {
-        realpath("./", exe_dir);
+        // Get current working directory if not in bundle
+        if (getcwd(exe_dir, size) == NULL) {
+            exe_dir[0] = '\0';
+        }
     }
 }
 
@@ -729,8 +789,11 @@ static void build_python_command(
 
 // macOS Console entry point
 int main(int argc, char* argv[]) {
+    (void)argc;
+    (void)argv;
     char exe_dir[MAX_PATH_LEN];
-    char cmd[MAX_PATH_LEN * 2];
+    char cmd[MAX_PATH_LEN * 3];
+    char python_runtime[MAX_PATH_LEN];
     pid_t pid;
     int status;
 
@@ -738,7 +801,6 @@ int main(int argc, char* argv[]) {
     get_exe_dir_macos(exe_dir, MAX_PATH_LEN);
 
     // Check Python runtime
-    char python_runtime[MAX_PATH_LEN];
     snprintf(python_runtime, MAX_PATH_LEN, "%s/runtime/bin/python3", exe_dir);
     if (!check_python_runtime(python_runtime)) {
         fprintf(stderr, "Error: Python runtime not found at %s/runtime/bin/\n", exe_dir);
@@ -772,79 +834,125 @@ int main(int argc, char* argv[]) {
 }
 """
 
-_COMPILER_OPTIONS: dict[str, list[str]] = {
-    "gcc": ["-std=c99", "-Wall", "-Wextra", "-pedantic", "-O2", "-D_GNU_SOURCE"],
-    "clang": ["-std=c99", "-Wall", "-Wextra", "-pedantic", "-O2", "-D_GNU_SOURCE"],
-    "cl": ["/std:c99", "/Wall", "/Wextra", "/pedantic", "/O2", "/D_GNU_SOURCE"],
-}
+ENTRY_FILE_TEMPLATE = r"""
+import os
+import sys
+from pathlib import Path
 
+# Setup environment
+cwd = Path.cwd()
+site_dirs = [cwd / "site-packages", cwd / "lib"]
+dirs = [cwd, cwd / "src", cwd / "runtime", *site_dirs]
+
+for dir in dirs:
+    sys.path.append(str(dir))
+
+# Fix zipimporter compatibility for packages imported from zip archives
+# Some packages (e.g., markdown) require exec_module on zipimporter
+import zipimport
+if not hasattr(zipimport.zipimporter, 'exec_module'):
+    def _create_module(self, spec):
+        return None
+    def _exec_module(self, module):
+        code = self.get_code(module.__name__)
+        exec(code, module.__dict__)
+    zipimport.zipimporter.create_module = _create_module
+    zipimport.zipimporter.exec_module = _exec_module
+
+# Qt configuration (optional)
+$QT_CONFIG
+
+# Main entry point
+from src.$PROJECT_NAME.$ENTRY_NAME import main
+main()
+"""
 
-def find_compiler() -> str | None:
-    """Find the path to the specified compiler."""
-    compilers = _COMPILER_OPTIONS.keys()
+# Compiler configurations using frozenset for better performance
+_COMPILER_CONFIGS: frozenset[CompilerConfig] = frozenset([
+    CompilerConfig(name="gcc", args=("-std=c99", "-Wall", "-O2")),
+    CompilerConfig(name="clang", args=("-std=c99", "-Wall", "-O2")),
+    CompilerConfig(name="cl", args=("/std:c99", "/O2")),
+])
 
-    for compiler in compilers:
-        if shutil.which(compiler) is not None:
-            return compiler
 
+def find_compiler() -> str | None:
+    """Find available C compiler."""
+    for compiler in ("gcc", "clang", "cl"):
+        if shutil.which(compiler):
+            return compiler
     logger.error("No compiler found")
     return None
 
 
-def get_compiler_args(
-    compiler: str,
-) -> list[str]:
-    """Get the arguments for the specified compiler."""
-    compiler_name = Path(compiler).stem if "\\" in compiler or "/" in compiler else compiler
+def get_compiler_args(compiler: str) -> list[str]:
+    """Get compiler arguments for specified compiler.
 
-    if compiler_name in ("gcc", "clang"):
-        return ["-std=c99", "-Wall", "-pedantic", "-Werror"]
-    elif compiler_name == "cl":
-        return ["/std:c99", "/Wall", "/WX", "/Werror"]
-    else:
-        return []
+    Args:
+        compiler: Compiler name or path
+
+    Returns:
+        List of compiler arguments
+    """
+    compiler_name = (
+        Path(compiler).stem if "\\" in compiler or "/" in compiler else compiler
+    )
 
+    for config in _COMPILER_CONFIGS:
+        if config.name == compiler_name:
+            return config.to_list()
 
-def select_template(
-    loader_type: str,
-    is_debug: bool,
-) -> str:
+    return []
+
+
+def select_c_template(loader_type: str, debug: bool) -> str:
     """Select the appropriate C code template based on platform and type.
 
     In debug mode, always use console template to ensure output is visible.
     """
-    # In debug mode, always use console template for visibility
-    if is_debug:
-        if is_windows:
-            return _WINDOWS_CONSOLE_TEMPLATE
-        elif is_macos:
-            return _MACOS_CONSOLE_TEMPLATE
-        else:
-            return _UNIX_CONSOLE_TEMPLATE
+    if debug:
+        loader_type = "console"
 
-    # In non-debug mode, use the requested template type
     if is_windows:
-        if loader_type == "gui":
-            return _WINDOWS_GUI_TEMPLATE
-        else:
-            return _WINDOWS_CONSOLE_TEMPLATE
+        return (
+            _WINDOWS_GUI_TEMPLATE if loader_type == "gui" else _WINDOWS_CONSOLE_TEMPLATE
+        )
     elif is_macos:
-        if loader_type == "gui":
-            return _MACOS_GUI_TEMPLATE
-        else:
-            return _MACOS_CONSOLE_TEMPLATE
-    else:  # Linux and other Unix-like systems
-        if loader_type == "gui":
-            return _UNIX_GUI_TEMPLATE
-        else:
-            return _UNIX_CONSOLE_TEMPLATE
+        return _MACOS_GUI_TEMPLATE if loader_type == "gui" else _MACOS_CONSOLE_TEMPLATE
+    else:
+        return _UNIX_GUI_TEMPLATE if loader_type == "gui" else _UNIX_CONSOLE_TEMPLATE
 
 
-def generate_c_source(
-    template: str,
-    entry_file: str,
-    is_debug: bool,
-) -> str:
+def prepare_entry_file(project: Project, entry_stem: str) -> str:
+    """Generate entry file code by replacing placeholders in template.
+
+    Args:
+        project_name: Project name
+        entry_stem: Entry file name without extension (e.g., "myapp" for "myapp.py" or "myapp.ent")
+        is_qt: Whether this is a Qt application
+
+    Returns:
+        Generated entry file code
+    """
+    qt_config = (
+        """# Qt configuration
+qt_dir = cwd / "site-packages" / "{$QT_NAME}"
+plugin_path = str(qt_dir / "plugins" / "platforms")
+os.environ["QT_QPA_PLATFORM_PLUGIN_PATH"] = plugin_path
+
+""".replace("$QT_NAME", project.qt_libname or "")
+        if project.has_qt
+        else ""
+    )
+
+    return (
+        ENTRY_FILE_TEMPLATE
+        .replace("$PROJECT_NAME", project.name.replace("-", "_"))
+        .replace("$ENTRY_NAME", entry_stem)
+        .replace("$QT_CONFIG", qt_config)
+    )
+
+
+def prepare_c_source(template: str, entry_file: str, is_debug: bool) -> str:
     """Generate C source code by replacing placeholders in template."""
     # Replace placeholders
     c_code = template.replace("${ENTRY_FILE}", entry_file)
@@ -877,7 +985,9 @@ def compile_c_source(
     output_filepath = output_filepath.with_suffix(ext)
 
     # Build compile command
-    compiler_name = Path(compiler).name if "\\" in compiler or "/" in compiler else compiler
+    compiler_name = (
+        Path(compiler).name if "\\" in compiler or "/" in compiler else compiler
+    )
     if compiler_name.lower() == "cl" or compiler_name.lower() == "cl.exe":
         # MSVC compiler
         cmd = [
@@ -886,7 +996,9 @@ def compile_c_source(
             str(c_source_path),
             f"/Fe:{output_filepath}",
             "/link",
-            "/SUBSYSTEM:WINDOWS" if "gui" in str(c_source_path).lower() else "/SUBSYSTEM:CONSOLE",
+            "/SUBSYSTEM:WINDOWS"
+            if "gui" in str(c_source_path).lower()
+            else "/SUBSYSTEM:CONSOLE",
         ]
     else:
         # GCC/Clang compiler
@@ -894,7 +1006,14 @@ def compile_c_source(
         # For Windows GUI, add -mwindows flag with gcc/clang
         if is_windows and "gui" in str(c_source_path).lower():
             subsystem_flag = ["-mwindows"]
-        cmd = [compiler, *compiler_args, *subsystem_flag, "-o", str(output_filepath), str(c_source_path)]
+        cmd = [
+            compiler,
+            *compiler_args,
+            *subsystem_flag,
+            "-o",
+            str(output_filepath),
+            str(c_source_path),
+        ]
 
     logger.debug(f"Compiling with command: {' '.join(cmd)}")
     try:
@@ -914,82 +1033,248 @@ def compile_c_source(
         return False
 
 
-def main():
-    parser = argparse.ArgumentParser(description="Generate a Python loader executable for current platform")
-    parser.add_argument("--debug", "-d", action="store_true", help="Enable debug mode")
-    parser.add_argument(
-        "-t", "--type", choices=["gui", "console"], default="console", help="Loader type (default: console)"
-    )
-    parser.add_argument("-o", "--output", default="", help="Output executable path (default: pyloader or pyloader.exe)")
-    parser.add_argument(
-        "-e", "--entry-file", default="main.py", help="Entry Python file path to execute (default: main.py)"
-    )
-    parser.add_argument(
-        "--compiler", help="Specify compiler to use. Examples: gcc, clang, cl, or full path like C:\\vc\\bin\\cl.exe"
-    )
-    parser.add_argument("--run", "-r", action="store_true", help="Run the generated executable after compilation")
+def _is_entry_file(file_path: Path) -> bool:
+    """Check if a Python file is an entry file.
 
-    args = parser.parse_args()
+    An entry file must contain either:
+    - def main() function
+    - if __name__ == '__main__': block
 
-    if args.debug:
-        logger.setLevel(logging.DEBUG)
+    Args:
+        file_path: Path to Python file
 
-    # Determine default output file name based on platform and type
-    output_filepath = cwd / f"pyloader{ext}" if not args.output else Path(args.output)
+    Returns:
+        True if file is an entry file, False otherwise
+    """
+    if not file_path.is_file():
+        return False
 
-    # Select appropriate template (in debug mode, always use console)
-    template = select_template(args.type, args.debug)
+    try:
+        content = file_path.read_text(encoding="utf-8")
+        return (
+            "def main(" in content
+            or "if __name__ == '__main__':" in content
+            or 'if __name__ == "__main__":' in content
+        )
+    except Exception as e:
+        logger.debug(f"Failed to read {file_path}: {e}")
+        return False
 
-    # Generate C source code
-    c_code = generate_c_source(template, args.entry_file, args.debug)
 
-    # Write C source code to file
-    # File name should reflect actual template type, not just args.type
-    # (debug mode forces console template)
-    if args.debug:
-        c_source_file = "pyloader_debug_console.c"
-    elif args.type == "console":
-        c_source_file = "pyloader_console.c"
-    else:  # gui type in non-debug mode
-        c_source_file = "pyloader_gui.c"
+def _detect_entry_files(
+    project_dir: Path,
+    project_name: str,
+) -> list[EntryFile]:
+    """Detect all entry files in project directory.
 
-    c_source_path = Path(c_source_file)
-    c_source_path.write_text(c_code, encoding="utf-8")
-    logger.info(f"Generated C source code: {c_source_path}")
+    Args:
+        project_dir: Project directory
+        project_name: Project name
+
+    Returns:
+        List of tuples (entry_file_name, module_name, is_gui)
+        e.g., [("docscan", "docscan", False), ("docscan-gui", "docscan_gui", True)]
+    """
+    normalized_name = project_name.replace("-", "_")
+    entry_files: list[EntryFile] = []
+
+    # Scan all Python files in project directory
+    for py_file in project_dir.glob("*.py"):
+        if not _is_entry_file(py_file):
+            continue
+
+        entry_file = EntryFile(project_name=normalized_name, source_file=py_file)
+        entry_files.append(entry_file)
+        logger.debug(f"Found entry file: {entry_file}")
+
+    return entry_files
+
+
+def _generate_single_loader(
+    project: Project,
+    project_dir: Path,
+    entry_file: EntryFile,
+    is_debug: bool,
+) -> bool:
+    """Generate a single loader executable and entry file.
+
+    Args:
+        project_dir: Project directory
+        entry_name: Entry file name (e.g., "docscan", "docscan-gui")
+        entry_module: Python module name (e.g., "docscan", "docscan_gui")
+        loader_type: Loader type ("console" or "gui")
+        use_qt: Whether this is a Qt application
+        is_debug: Whether to generate debug version
+        compiler: Optional compiler to use
+
+    Returns:
+        True if successful, False otherwise
+    """
+    entry_name = entry_file.entry_name
+
+    # Prepare directories
+    build_dir = project_dir / ".cbuild"
+    output_dir = project_dir / "dist"
+    build_dir.mkdir(parents=True, exist_ok=True)
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    # Output paths
+    output_exe = output_dir / f"{entry_name}{ext}"
+    c_source_filename = (
+        f"{entry_name}_debug_console.c"
+        if is_debug
+        else f"{entry_name}_{project.is_gui}.c"
+    )
+    entry_filepath = output_dir / f"{entry_name}.ent"
+    c_source_path = build_dir / c_source_filename
 
     t0 = time.perf_counter()
 
-    # Compile to executable
-    if compile_c_source(c_source_file, output_filepath, args.compiler):
-        logger.info("Loader executable generated successfully!")
-        logger.debug(f"Platform: {platform.system()}")
-        logger.debug(f"Type: {args.type}")
-        logger.debug(f"Debug mode: {args.debug}")
-        logger.debug(f"Python entry file: {args.entry_file}")
-        logger.debug(f"Output: {output_filepath}")
-
-        # Run the executable if --run flag is set
-        if args.run:
-            logger.debug("\nRunning the executable...")
-            import subprocess
-
-            try:
-                subprocess.run([str(Path(args.output))], check=True)
-            except subprocess.CalledProcessError as e:
-                logger.error(f"\nExecutable exited with code: {e.returncode}")
-                return e.returncode
-            except FileNotFoundError:
-                logger.error(f"\nError: Executable not found at {args.output}")
-                return 1
-
-        logger.info(f"Compilation time: {time.perf_counter() - t0:.4f} seconds")
-        return 0
+    # Generate entry file
+    # Extract project name from entry_name (remove -gui suffix if present)
+    entry_file_code = prepare_entry_file(project=project, entry_stem=entry_name)
+    entry_filepath.write_text(entry_file_code, encoding="utf-8")
+    logger.debug(f"Generated entry file: {entry_filepath}")
+
+    # Generate and compile C source
+    c_template = select_c_template(project.loader_type, is_debug)
+    c_code = prepare_c_source(c_template, entry_filepath.name, is_debug)
+    c_source_path.write_text(c_code, encoding="utf-8")
+    logger.debug(f"Generated C source code: {c_source_path}")
+
+    compiler = find_compiler()
+    if not compiler:
+        logger.error(f"Failed to find compiler: {compiler}")
+        return False
+
+    success = compile_c_source(c_source_path, output_exe, compiler)
+    if success:
+        logger.info(f"Loader executable generated successfully: {output_exe}")
+        logger.debug(f"Entry: {entry_file}")
+        logger.debug(f"Type: {project.loader_type}")
+        logger.debug(f"Qt: {project.has_qt}")
+        logger.debug(f"Debug mode: {is_debug}")
+        logger.debug(f"Compilation time: {time.perf_counter() - t0:.4f} seconds")
     else:
-        logger.error("\nFailed to compile loader executable")
-        return 1
+        logger.error(f"Failed to compile loader for {entry_name}")
 
+    return success
 
-if __name__ == "__main__":
-    import sys
 
-    sys.exit(main())
+def generate_loader_for_project(
+    project: Project,
+    project_dir: Path,
+    debug: bool = False,
+):
+    """Generate loader executables and entry files for a single project.
+
+    This function detects all entry files (main and GUI versions) and generates
+    a loader for each one.
+
+    Args:
+        project: Project information dataclass
+        project_dir: Directory containing the project (pyproject.toml location)
+        debug: Whether to generate debug version
+    """
+    # Determine base loader type and Qt usage from project info
+    # Detect all entry files in project directory
+    entry_files = _detect_entry_files(project_dir, project.name)
+    if not entry_files:
+        logger.error(f"No entry files found in {project_dir}")
+        return False
+
+    # Generate loaders for all entry files
+    for entry_file in entry_files:
+        logger.debug(f"Generating loader for: {entry_file.project_name}")
+        if not _generate_single_loader(
+            project=project,
+            project_dir=project_dir,
+            entry_file=entry_file,
+            is_debug=debug,
+        ):
+            return False
+
+    return True
+
+
+def generate_loader(base_dir: Path, debug: bool) -> None:
+    """Generate loader executables for all projects in the given directory."""
+    from sfi.pyprojectparse.pyprojectparse import Solution
+
+    projects = Solution.projects
+    if not projects:
+        logger.error("Failed to load project information")
+
+    success_count = 0
+    failed_projects: list[str] = []
+
+    if len(projects) == 1:
+        logger.debug("Only one project found, using current directory")
+        project_dir = base_dir
+        if generate_loader_for_project(
+            project=next(iter(projects.values())),
+            project_dir=project_dir,
+            debug=debug,
+        ):
+            success_count += 1
+        else:
+            failed_projects.append(next(iter(projects)))
+    else:
+        for project_name, project in projects.items():
+            project_dir = base_dir / project_name
+            if not project_dir.is_dir():
+                logger.error(f"Project directory not found: {project_dir}, skipping...")
+                failed_projects.append(project_name)
+                continue
+
+            if generate_loader_for_project(
+                project=project,
+                project_dir=project_dir,
+                debug=debug,
+            ):
+                success_count += 1
+            else:
+                failed_projects.append(project_name)
+
+    logger.info(f"Pack {success_count}/{len(projects)} projects successfully")
+
+    if failed_projects:
+        logger.error(f"Failed: {failed_projects}")
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Generate Python loader executables for all projects in directory"
+    )
+    parser.add_argument(
+        "directory",
+        nargs="?",
+        default=str(cwd),
+        help="Directory containing projects (will create/load projects.json)",
+    )
+    parser.add_argument("--debug", "-d", action="store_true", help="Enable debug mode")
+    parser.add_argument(
+        "--compiler",
+        help="Specify compiler to use. Examples: gcc, clang, cl, or full path like C:\\vc\\bin\\cl.exe",
+    )
+    return parser.parse_args()
+
+
+def main():
+    """Main entry point for pyloadergen."""
+    args = parse_args()
+
+    if args.debug:
+        logger.setLevel(logging.DEBUG)
+
+    working_dir = Path(args.directory)
+    if not working_dir.is_dir():
+        logger.error(f"Directory does not exist: {working_dir}")
+        return
+
+    logger.info(f"Working directory: {working_dir}")
+    generate_loader(working_dir, args.debug)
+
+
+if __name__ == "__main__":
+    main()