pysfi 0.1.6__py3-none-any.whl → 0.1.10__py3-none-any.whl

sfi/pyloadergen/pyloadergen.py

@@ -1,12 +1,15 @@
 from __future__ import annotations
 
 import argparse
+import json
 import logging
 import platform
 import shutil
 import subprocess
 import time
+from dataclasses import dataclass, field
 from pathlib import Path
+from typing import Any
 
 is_windows = platform.system() == "Windows"
 is_linux = platform.system() == "Linux"
@@ -17,6 +20,84 @@ logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
 logger = logging.getLogger(__name__)
 cwd = Path.cwd()
 
+
+@dataclass(frozen=True)
+class ProjectInfo:
+    """Project information dataclass.
+
+    Attributes:
+        name: Project name
+        version: Project version
+        description: Project description
+        dependencies: List of project dependencies
+        keywords: Project keywords
+        scripts: Entry point scripts
+    """
+
+    name: str
+    version: str = "0.0.0"
+    description: str = ""
+    dependencies: list[str] = field(default_factory=list)
+    keywords: list[str] = field(default_factory=list)
+    scripts: dict[str, str] = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls, project_name: str, data: dict[str, Any]) -> ProjectInfo:
+        """Create ProjectInfo from dictionary.
+
+        Args:
+            project_name: Project name
+            data: Dictionary containing project information
+
+        Returns:
+            ProjectInfo instance
+        """
+        return cls(
+            name=project_name,
+            version=data.get("version", "0.0.0"),
+            description=data.get("description", ""),
+            dependencies=data.get("dependencies", []),
+            keywords=data.get("keywords", []),
+            scripts=data.get("scripts", {}),
+        )
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert ProjectInfo to dictionary.
+
+        Returns:
+            Dictionary representation of ProjectInfo
+        """
+        return {
+            "name": self.name,
+            "version": self.version,
+            "description": self.description,
+            "dependencies": self.dependencies,
+            "keywords": self.keywords,
+            "scripts": self.scripts,
+        }
+
+
+@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)
+
+
 _WINDOWS_GUI_TEMPLATE: str = r"""#include <windows.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -36,7 +117,8 @@ 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];
@@ -57,10 +139,18 @@ static void build_python_command(
     // 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);
+        if (lpCmdLine && strlen(lpCmdLine) > 0) {
+            snprintf(cmd, MAX_PATH_LEN, "\"%s\" -u \"%s\" %s", python_runtime, script_path, lpCmdLine);
+        } else {
+            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);
+        if (lpCmdLine && strlen(lpCmdLine) > 0) {
+            snprintf(cmd, MAX_PATH_LEN, "\"%s\" -u \"%s\" %s 2>&1", python_runtime, script_path, lpCmdLine);
+        } else {
+            snprintf(cmd, MAX_PATH_LEN, "\"%s\" -u \"%s\" 2>&1", python_runtime, script_path);
+        }
     }
 }
 
@@ -132,7 +222,7 @@ int APIENTRY WinMain(
     }
 
     // Build and execute Python command
-    build_python_command(cmd, exe_dir, "${ENTRY_FILE}", ${DEBUG_MODE});
+    build_python_command(cmd, exe_dir, "${ENTRY_FILE}", ${DEBUG_MODE}, lpCmdLine);
 
     // Create pipe for capturing output
     sa.nLength = sizeof(SECURITY_ATTRIBUTES);
@@ -199,7 +289,13 @@ int APIENTRY WinMain(
     GetExitCodeProcess(pi.hProcess, &exit_code);
 
     // Debug output
-    fprintf(stderr, "DEBUG: Python process exited with code: %lu\n", exit_code);
+    if (${DEBUG_MODE}) {
+#ifdef _WIN32
+        fwprintf(stderr, L"DEBUG: Python process exited with code: %lu\n", exit_code);
+#else
+        fprintf(stderr, "DEBUG: Python process exited with code: %lu\n", exit_code);
+#endif
+    }
 
     // Cleanup
     CloseHandle(pi.hProcess);
@@ -227,6 +323,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,7 +342,8 @@ 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];
@@ -257,10 +355,30 @@ static void build_python_command(
     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);
+    // Include original command line arguments
+    snprintf(cmd, MAX_PATH_LEN, "\"%s\" -u \"%s\"", python_runtime, script_path);
+
+    // Append original command line arguments if any
+    if (argc > 1) {
+        strcat(cmd, " ");
+        for (int i = 1; i < argc; i++) {
+            strcat(cmd, "\"");
+            strcat(cmd, argv[i]);
+            strcat(cmd, "\"");
+            if (i < argc - 1) {
+                strcat(cmd, " ");
+            }
+        }
+    }
+}
+
+// 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,6 +388,7 @@ int main(int argc, char* argv[]) {
     char cmd[MAX_PATH_LEN * 2];
     STARTUPINFOA si = {0};
     PROCESS_INFORMATION pi = {0};
+    BOOL success;
 
     // Set encoding to UTF-8
     setup_encoding();
@@ -282,37 +401,65 @@ int main(int argc, char* argv[]) {
     }
 
     // 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
+    build_python_command(cmd, exe_dir, "${ENTRY_FILE}", argc, argv);
 
     // Debug output
     if (${DEBUG_MODE}) {
+#ifdef _WIN32
+        // On Windows, convert to wide characters for proper Unicode display
+        {
+            // Convert and print command
+            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);
+            }
+
+            // Convert and print exe_dir
+            int wdir_len = MultiByteToWideChar(CP_UTF8, 0, exe_dir, -1, NULL, 0);
+            if (wdir_len > 0) {
+                wchar_t* wdir = (wchar_t*)malloc(wdir_len * sizeof(wchar_t));
+                MultiByteToWideChar(CP_UTF8, 0, exe_dir, -1, wdir, wdir_len);
+                fwprintf(stderr, L"DEBUG: exe_dir: %ls\n", wdir);
+                free(wdir);
+            }
+        }
+#else
         fprintf(stderr, "DEBUG: Command to execute: %s\n", cmd);
         fprintf(stderr, "DEBUG: exe_dir: %s\n", exe_dir);
+#endif
     }
 
-    // Set startup info to inherit console
+    // Set startup info
     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);
+    // For console applications, always inherit console handles to display output directly
+    // Don't use pipes in non-debug mode to allow all output to display in console
+    if (${DEBUG_MODE}) {
+        // Debug mode: do not use pipe, inherit console to display output directly
+        // Keep si.dwFlags as 0, do not set STARTF_USESTDHANDLES
+    } else {
+        // Production mode for console apps: inherit console handles to show ALL output in console
+        // Do not use pipes at all to ensure all stdout/stderr displays in console
+    }
 
     // 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 +467,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);
 
@@ -336,10 +486,11 @@ int main(int argc, char* argv[]) {
     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,6 +533,7 @@ static void build_python_command(
 
 // Unix GUI entry point
 int main(int argc, char* argv[]) {
+    (void)argc;  // Unused parameter (argv[0] is used)
     char exe_dir[MAX_PATH_LEN];
     char cmd[MAX_PATH_LEN * 2];
     char log_file[MAX_PATH_LEN];
@@ -471,6 +623,8 @@ static void build_python_command(
 
 // Unix Console entry point
 int main(int argc, char* argv[]) {
+    (void)argc;  // Unused parameter
+    (void)argv;  // Unused parameter
     char exe_dir[MAX_PATH_LEN];
     char cmd[MAX_PATH_LEN * 2];
     pid_t pid;
@@ -558,10 +712,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,6 +757,8 @@ static void build_python_command(
 
 // macOS GUI entry point
 int main(int argc, char* argv[]) {
+    (void)argc;  // Unused parameter
+    (void)argv;  // Unused parameter
     char exe_dir[MAX_PATH_LEN];
     char cmd[MAX_PATH_LEN * 2];
     char log_file[MAX_PATH_LEN];
@@ -729,6 +885,8 @@ static void build_python_command(
 
 // macOS Console entry point
 int main(int argc, char* argv[]) {
+    (void)argc;  // Unused parameter
+    (void)argv;  // Unused parameter
     char exe_dir[MAX_PATH_LEN];
     char cmd[MAX_PATH_LEN * 2];
     pid_t pid;
@@ -772,40 +930,89 @@ 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_FILE 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")),
+])
+
+# Qt-related keywords and dependencies for faster detection
+_QT_DEPENDENCIES: frozenset[str] = frozenset((
+    "qt",
+    "pyside",
+    "pyqt",
+    "pyside2",
+    "pyside6",
+    "pyqt5",
+    "pyqt6",
+    "qt5",
+    "qt6",
+))
+_GUI_KEYWORDS: frozenset[str] = frozenset(("gui", "desktop"))
 
-    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."""
+def get_compiler_args(compiler: str) -> list[str]:
+    """Get compiler arguments for specified compiler.
+
+    Args:
+        compiler: Compiler name or path
+
+    Returns:
+        List of compiler arguments
+    """
     compiler_name = Path(compiler).stem if "\\" in compiler or "/" in compiler else 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 []
+    for config in _COMPILER_CONFIGS:
+        if config.name == compiler_name:
+            return config.to_list()
 
+    return []
 
-def select_template(
+
+def select_c_template(
     loader_type: str,
     is_debug: bool,
 ) -> str:
@@ -840,7 +1047,33 @@ def select_template(
             return _UNIX_CONSOLE_TEMPLATE
 
 
-def generate_c_source(
+def prepare_entry_file(entry_stem: str, is_qt: bool) -> str:
+    """Generate entry file code by replacing placeholders in template.
+
+    Args:
+        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
+    """
+    entry_file_code = ENTRY_FILE_TEMPLATE.replace("$PROJECT_NAME", entry_stem)
+
+    # Add Qt configuration if needed
+    if is_qt:
+        qt_config = """# Qt configuration
+qt_dir = cwd / "site-packages" / "PySide2"
+plugin_path = str(qt_dir / "plugins" / "platforms")
+os.environ["QT_QPA_PLATFORM_PLUGIN_PATH"] = plugin_path
+
+"""
+    else:
+        qt_config = ""
+
+    return entry_file_code.replace("$QT_CONFIG", qt_config)
+
+
+def prepare_c_source(
     template: str,
     entry_file: str,
     is_debug: bool,
@@ -914,79 +1147,432 @@ 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)")
+def ensure_projects_json(directory: Path) -> Path | None:
+    """Ensure projects.json exists by running projectparse if needed.
+
+    Args:
+        directory: Directory to check for projects.json
+
+    Returns:
+        Path to projects.json if successful, None otherwise
+    """
+    projects_json = directory / "projects.json"
+    if projects_json.exists():
+        logger.debug(f"Found existing projects.json at {projects_json}")
+        return projects_json
+
+    logger.info("projects.json not found, running projectparse...")
+
+    try:
+        import sys
+
+        from sfi.projectparse import projectparse as pp
+
+        original_argv = sys.argv.copy()
+        sys.argv = ["projectparse", "--directory", str(directory), "--output", "projects.json", "--recursive"]
+        try:
+            pp.main()
+        finally:
+            sys.argv = original_argv
+
+        return projects_json if projects_json.exists() else None
+    except ImportError:
+        sfi_dir = Path(__file__).parent.parent.parent
+        projectparse_script = sfi_dir / "projectparse" / "projectparse.py"
+
+        if not projectparse_script.exists():
+            logger.error(f"Cannot find projectparse script at {projectparse_script}")
+            return None
+
+        result = subprocess.run(
+            [
+                "python",
+                str(projectparse_script),
+                "--directory",
+                str(directory),
+                "--output",
+                "projects.json",
+                "--recursive",
+            ],
+            capture_output=True,
+            text=True,
+            cwd=directory,
+        )
+        if result.returncode == 0 and projects_json.exists():
+            logger.info("projectparse completed successfully")
+            return projects_json
+        logger.error(f"projectparse failed: {result.stderr}")
+        return None
+    except Exception as e:
+        logger.error(f"Failed to run projectparse: {e}")
+        return None
+
+
+def load_projects_json(projects_json: Path) -> dict | None:
+    """Load project information from projects.json.
+
+    Args:
+        projects_json: Path to projects.json file
+
+    Returns:
+        Dictionary of project information, None if failed
+    """
+    try:
+        with open(projects_json, encoding="utf-8") as f:
+            return json.load(f)
+    except Exception as e:
+        logger.error(f"Failed to load projects.json: {e}")
+        return None
+
+
+def _detect_loader_type(project_info: ProjectInfo) -> tuple[str, bool]:
+    """Detect loader type and Qt usage from project info.
+
+    Args:
+        project_info: Project information dataclass
+
+    Returns:
+        Tuple of (loader_type: str, use_qt: bool)
+    """
+    # Convert dependencies and keywords to frozenset for O(1) lookup
+    deps_lower = frozenset(dep.lower() for dep in project_info.dependencies)
+    keywords_lower = frozenset(kw.lower() for kw in project_info.keywords)
+
+    # Check for Qt dependencies using set intersection (O(min(n,m)) instead of O(n*m))
+    use_qt = bool(deps_lower.intersection(_QT_DEPENDENCIES))
+
+    # Determine loader type: GUI if has Qt dependencies or GUI keywords
+    loader_type = "gui" if use_qt or bool(keywords_lower.intersection(_GUI_KEYWORDS)) else "console"
+    return loader_type, use_qt
+
+
+def _get_entry_module(project_info: ProjectInfo) -> str:
+    """Get entry module from project info.
+
+    Args:
+        project_info: Project information dataclass
+
+    Returns:
+        Entry module name
+    """
+    if not project_info.scripts:
+        return project_info.name.replace("-", "_")
+    first_script = next(iter(project_info.scripts.values()))
+    return first_script.split(":")[0].strip()
+
+
+def _is_entry_file(file_path: Path) -> bool:
+    """Check if a Python file is an entry file.
+
+    An entry file must contain either:
+    - def main() function
+    - if __name__ == '__main__': block
+
+    Args:
+        file_path: Path to Python file
+
+    Returns:
+        True if file is an entry file, False otherwise
+    """
+    if not file_path.exists() or not file_path.is_file():
+        return False
+
+    try:
+        content = file_path.read_text(encoding="utf-8")
+        # Check for def main() or def main(
+        has_main_func = "def main(" in content or "def main():" in content
+        # Check for if __name__ == '__main__':
+        has_main_block = "if __name__ == '__main__':" in content or 'if __name__ == "__main__":' in content
+        return has_main_func or has_main_block
+    except Exception as e:
+        logger.debug(f"Failed to read {file_path}: {e}")
+        return False
+
+
+def _detect_entry_files(project_dir: Path, project_name: str, loader_type: str) -> list[tuple[str, str, bool]]:
+    """Detect all entry files in project directory.
+
+    Args:
+        project_dir: Project directory
+        project_name: Project name
+        loader_type: Base loader type from project info
+
+    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 = []
+
+    # Scan all Python files in project directory
+    for py_file in project_dir.glob("*.py"):
+        if not _is_entry_file(py_file):
+            continue
+
+        # Get file stem (name without .py extension)
+        file_stem = py_file.stem
+
+        # Determine if this is a GUI entry based on file name
+        is_gui_file = file_stem.endswith("_gui")
+
+        # Generate entry name (use hyphen for GUI version)
+        if is_gui_file:
+            # e.g., "docscan_gui" -> "docscan-gui"
+            base_name = file_stem.replace("_gui", "")
+            entry_name = f"{base_name}-gui"
+        else:
+            entry_name = file_stem
+
+        # Module name is just the file stem
+        module_name = file_stem
+
+        entry_files.append((entry_name, module_name, is_gui_file))
+        logger.debug(f"Found entry file: {py_file.name} -> {entry_name} (GUI: {is_gui_file})")
+
+    # If no entry files found, fallback to default
+    if not entry_files:
+        logger.warning(f"No entry files found in {project_dir}, using default: {normalized_name}.py")
+        entry_files.append((project_name, normalized_name, False))
+
+    return entry_files
+
+
+def generate_loader(
+    project_name: str,
+    projects_json_path: Path,
+    is_debug: bool = False,
+    compiler: str | None = None,
+) -> bool:
+    """Generate loader executable and entry file from projects.json.
+
+    Args:
+        project_name: Name of the project to generate loader for
+        projects_json_path: Path to projects.json file
+        is_debug: Whether to generate debug version
+        compiler: Optional compiler to use
+
+    Returns:
+        True if successful, False otherwise
+    """
+    # Load projects.json
+    projects_data = load_projects_json(projects_json_path)
+    if not projects_data:
+        logger.error("Failed to load projects.json")
+        return False
+
+    # Check if project exists
+    if project_name not in projects_data:
+        logger.error(f"Project '{project_name}' not found in projects.json")
+        return False
+
+    # Convert to ProjectInfo
+    project_info = ProjectInfo.from_dict(project_name, projects_data[project_name])
+    project_dir = projects_json_path.parent
+
+    return generate_loader_for_project(project_dir, project_info, is_debug, compiler)
+
+
+def _generate_single_loader(
+    project_dir: Path,
+    entry_name: str,
+    entry_module: str,
+    loader_type: str,
+    use_qt: bool,
+    is_debug: bool,
+    compiler: str | None,
+) -> 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
+    """
+    # 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}_{loader_type}.c"
+    entry_filepath = output_dir / f"{entry_name}.ent"
+    c_source_path = build_dir / c_source_filename
+
+    t0 = time.perf_counter()
+
+    # Generate entry file
+    # Extract project name from entry_name (remove -gui suffix if present)
+    project_name = entry_name.replace("-gui", "")
+    entry_file_code = prepare_entry_file(project_name, use_qt)
+    entry_file_code = entry_file_code.replace("$ENTRY_FILE", entry_module)
+    entry_filepath.write_text(entry_file_code, encoding="utf-8")
+    logger.info(f"Generated entry file: {entry_filepath}")
+
+    # Generate and compile C source
+    c_template = select_c_template(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.info(f"Generated C source code: {c_source_path}")
+
+    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_name}")
+        logger.debug(f"Module: {entry_module}")
+        logger.debug(f"Type: {loader_type}")
+        logger.debug(f"Debug mode: {is_debug}")
+        logger.debug(f"Compilation time: {time.perf_counter() - t0:.4f} seconds")
+    else:
+        logger.error(f"Failed to compile loader for {entry_name}")
+
+    return success
+
+
+def generate_loader_for_project(
+    project_dir: Path,
+    project_info: ProjectInfo,
+    is_debug: bool = False,
+    compiler: str | None = None,
+) -> bool:
+    """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_dir: Directory containing the project (pyproject.toml location)
+        project_info: Project information dataclass
+        is_debug: Whether to generate debug version
+        compiler: Optional compiler to use
+
+    Returns:
+        True if all loaders generated successfully, False otherwise
+    """
+    logger.info(f"\n{'=' * 60}")
+    logger.info(f"Generating loaders for project: {project_info.name}")
+    logger.info(f"{'=' * 60}")
+
+    # Determine base loader type and Qt usage from project info
+    base_loader_type, use_qt = _detect_loader_type(project_info)
+
+    # Detect all entry files in project directory
+    entry_files = _detect_entry_files(project_dir, project_info.name, base_loader_type)
+    logger.info(f"Found {len(entry_files)} entry file(s): {[e[0] for e in entry_files]}")
+
+    # Generate loader for each entry file
+    all_success = True
+    for entry_name, entry_module, is_gui in entry_files:
+        logger.info(f"\n--- Generating loader for: {entry_name} ---")
+
+        # Use GUI loader type for GUI entries, otherwise use base type
+        loader_type = "gui" if is_gui else base_loader_type
+        logger.debug(f"Loader type: {loader_type}")
+        logger.debug(f"Use Qt: {use_qt}")
+        logger.debug(f"Entry module: {entry_module}")
+
+        success = _generate_single_loader(
+            project_dir=project_dir,
+            entry_name=entry_name,
+            entry_module=entry_module,
+            loader_type=loader_type,
+            use_qt=use_qt,
+            is_debug=is_debug,
+            compiler=compiler,
+        )
+
+        if not success:
+            all_success = False
+            logger.error(f"Failed to generate loader for {entry_name}")
+
+    return all_success
+
+
+def main() -> int:
+    """Main entry point for pyloadergen.
+
+    Returns:
+        Exit code (0 for success, 1 for failure)
+    """
+    parser = argparse.ArgumentParser(description="Generate Python loader executables for all projects in directory")
     parser.add_argument(
-        "-e", "--entry-file", default="main.py", help="Entry Python file path to execute (default: main.py)"
+        "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"
     )
-    parser.add_argument("--run", "-r", action="store_true", help="Run the generated executable after compilation")
-
     args = parser.parse_args()
 
     if args.debug:
         logger.setLevel(logging.DEBUG)
 
-    # Determine default output file name based on platform and type
-    output_filepath = cwd / f"pyloader{ext}" if not args.output else Path(args.output)
+    base_dir = Path(args.directory)
+    if not base_dir.is_dir():
+        logger.error(f"Directory does not exist: {base_dir}")
+        return 1
 
-    # Select appropriate template (in debug mode, always use console)
-    template = select_template(args.type, args.debug)
+    logger.info(f"Working directory: {base_dir}")
 
-    # Generate C source code
-    c_code = generate_c_source(template, args.entry_file, args.debug)
+    # Ensure projects.json exists and load projects
+    projects_json = ensure_projects_json(base_dir)
+    if not projects_json:
+        logger.error("Failed to create projects.json")
+        return 1
 
-    # 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"
+    projects_data = load_projects_json(projects_json)
+    if not projects_data:
+        logger.error("Failed to load project information")
+        return 1
 
-    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}")
+    # Convert dict to ProjectInfo dataclasses
+    projects: dict[str, ProjectInfo] = {name: ProjectInfo.from_dict(name, data) for name, data in projects_data.items()}
 
-    t0 = time.perf_counter()
+    logger.info(f"Found {len(projects)} project(s) to process")
 
-    # 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
-    else:
-        logger.error("\nFailed to compile loader executable")
-        return 1
+    # Generate loaders
+    total_start = time.perf_counter()
+    success_count = 0
+    failed_projects: list[str] = []
+    use_current_dir = len(projects) == 1
+
+    if use_current_dir:
+        logger.debug("Only one project found, using current directory")
+
+    for project_name, project_info in projects.items():
+        project_dir = base_dir if use_current_dir else base_dir / project_name
+        if not project_dir.is_dir():
+            logger.warning(f"Project directory not found: {project_dir}, skipping")
+            failed_projects.append(project_name)
+            continue
+
+        if generate_loader_for_project(project_dir, project_info, args.debug, args.compiler):
+            success_count += 1
+        else:
+            failed_projects.append(project_name)
+
+    total_time = time.perf_counter() - total_start
+
+    # Print summary
+    logger.info(f"\n{'=' * 60}")
+    logger.info("Summary")
+    logger.info(f"{'=' * 60}")
+    logger.info(f"Total projects: {len(projects)}")
+    logger.info(f"Successfully generated: {success_count}")
+    logger.info(f"Failed: {len(failed_projects)}")
+    if failed_projects:
+        logger.info(f"Failed projects: {', '.join(failed_projects)}")
+    logger.info(f"Total time: {total_time:.4f} seconds")
+
+    return 0 if not failed_projects else 1
 
 
 if __name__ == "__main__":