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

sfi/pyloadergen/pyloadergen.py

@@ -1,15 +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 dataclasses import dataclass
 from pathlib import Path
-from typing import Any
+
+from sfi.pyprojectparse.pyprojectparse import Project
 
 is_windows = platform.system() == "Windows"
 is_linux = platform.system() == "Linux"
@@ -21,62 +21,6 @@ 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.
@@ -98,6 +42,22 @@ class CompilerConfig:
         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>
@@ -124,34 +84,17 @@ static void build_python_command(
     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
-        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
-        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);
-        }
-    }
+    // 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
@@ -159,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';
     }
 }
@@ -198,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};
@@ -221,33 +166,28 @@ int APIENTRY WinMain(
         return 1;
     }
 
-    // Build and execute Python command
-    build_python_command(cmd, exe_dir, "${ENTRY_FILE}", ${DEBUG_MODE}, lpCmdLine);
-
-    // 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
@@ -260,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"
@@ -288,14 +227,9 @@ int APIENTRY WinMain(
     DWORD exit_code;
     GetExitCodeProcess(pi.hProcess, &exit_code);
 
-    // Debug output
-    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);
+#if ${DEBUG_MODE}
+    fprintf(stderr, "DEBUG: Python process exited with code: %lu\n", exit_code);
 #endif
-    }
 
     // Cleanup
     CloseHandle(pi.hProcess);
@@ -347,6 +281,9 @@ static void build_python_command(
 ) {
     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);
@@ -354,21 +291,17 @@ 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)
-    // 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, " ");
-            }
-        }
+    // 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;
     }
 }
 
@@ -389,17 +322,16 @@ int main(int argc, char* argv[]) {
     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
     if (!check_python_runtime(exe_dir)) {
         fprintf(stderr, "Error: Python runtime not found at %s\\runtime\\\n", exe_dir);
@@ -407,50 +339,25 @@ int main(int argc, char* argv[]) {
         return 1;
     }
 
-    // Build Python command
+    // Build and execute Python command
     build_python_command(cmd, exe_dir, "${ENTRY_FILE}", argc, argv);
 
+#if ${DEBUG_MODE}
     // 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);
-            }
+    {
+        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);
         }
+    }
 #else
-        fprintf(stderr, "DEBUG: Command to execute: %s\n", cmd);
-        fprintf(stderr, "DEBUG: exe_dir: %s\n", exe_dir);
+    fprintf(stderr, "DEBUG: Command to execute: %s\n", cmd);
+#endif
 #endif
-    }
-
-    // Set startup info
-    si.cb = sizeof(si);
-
-    // 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
     // TRUE - inherit handles so Python can write to console
@@ -477,10 +384,9 @@ 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);
@@ -533,27 +439,23 @@ static void build_python_command(
 
 // Unix GUI entry point
 int main(int argc, char* argv[]) {
-    (void)argc;  // Unused parameter (argv[0] is used)
+    (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}");
@@ -623,12 +525,13 @@ static void build_python_command(
 
 // Unix Console entry point
 int main(int argc, char* argv[]) {
-    (void)argc;  // Unused parameter
-    (void)argv;  // Unused parameter
+    (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) {
@@ -637,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}");
@@ -703,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
@@ -757,11 +659,12 @@ static void build_python_command(
 
 // macOS GUI entry point
 int main(int argc, char* argv[]) {
-    (void)argc;  // Unused parameter
-    (void)argv;  // Unused parameter
+    (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;
 
@@ -769,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"
@@ -860,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';
+        }
     }
 }
 
@@ -885,10 +789,11 @@ static void build_python_command(
 
 // macOS Console entry point
 int main(int argc, char* argv[]) {
-    (void)argc;  // Unused parameter
-    (void)argv;  // Unused parameter
+    (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;
 
@@ -896,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);
@@ -959,7 +863,7 @@ if not hasattr(zipimport.zipimporter, 'exec_module'):
 $QT_CONFIG
 
 # Main entry point
-from src.$PROJECT_NAME.$ENTRY_FILE import main
+from src.$PROJECT_NAME.$ENTRY_NAME import main
 main()
 """
 
@@ -970,20 +874,6 @@ _COMPILER_CONFIGS: frozenset[CompilerConfig] = frozenset([
     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"))
-
 
 def find_compiler() -> str | None:
     """Find available C compiler."""
@@ -1003,7 +893,9 @@ def get_compiler_args(compiler: str) -> list[str]:
     Returns:
         List of compiler arguments
     """
-    compiler_name = Path(compiler).stem if "\\" in compiler or "/" in compiler else compiler
+    compiler_name = (
+        Path(compiler).stem if "\\" in compiler or "/" in compiler else compiler
+    )
 
     for config in _COMPILER_CONFIGS:
         if config.name == compiler_name:
@@ -1012,72 +904,55 @@ def get_compiler_args(compiler: str) -> list[str]:
     return []
 
 
-def select_c_template(
-    loader_type: str,
-    is_debug: bool,
-) -> str:
+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 prepare_entry_file(entry_stem: str, is_qt: 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
     """
-    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"
+    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
 
-"""
-    else:
-        qt_config = ""
+""".replace("$QT_NAME", project.qt_libname or "")
+        if project.has_qt
+        else ""
+    )
 
-    return entry_file_code.replace("$QT_CONFIG", qt_config)
+    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:
+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)
@@ -1110,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 = [
@@ -1119,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
@@ -1127,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:
@@ -1147,120 +1033,6 @@ def compile_c_source(
         return False
 
 
-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.
 
@@ -1274,112 +1046,55 @@ def _is_entry_file(file_path: Path) -> bool:
     Returns:
         True if file is an entry file, False otherwise
     """
-    if not file_path.exists() or not file_path.is_file():
+    if 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
+        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
 
 
-def _detect_entry_files(project_dir: Path, project_name: str, loader_type: str) -> list[tuple[str, str, bool]]:
+def _detect_entry_files(
+    project_dir: Path,
+    project_name: str,
+) -> list[EntryFile]:
     """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 = []
+    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
 
-        # 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))
+        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_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: Project,
     project_dir: Path,
-    entry_name: str,
-    entry_module: str,
-    loader_type: str,
-    use_qt: bool,
+    entry_file: EntryFile,
     is_debug: bool,
-    compiler: str | None,
 ) -> bool:
     """Generate a single loader executable and entry file.
 
@@ -1395,6 +1110,8 @@ def _generate_single_loader(
     Returns:
         True if successful, False otherwise
     """
+    entry_name = entry_file.entry_name
+
     # Prepare directories
     build_dir = project_dir / ".cbuild"
     output_dir = project_dir / "dist"
@@ -1403,7 +1120,11 @@ def _generate_single_loader(
 
     # 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"
+    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
 
@@ -1411,24 +1132,27 @@ def _generate_single_loader(
 
     # 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_file_code = prepare_entry_file(project=project, entry_stem=entry_name)
     entry_filepath.write_text(entry_file_code, encoding="utf-8")
-    logger.info(f"Generated entry file: {entry_filepath}")
+    logger.debug(f"Generated entry file: {entry_filepath}")
 
     # Generate and compile C source
-    c_template = select_c_template(loader_type, is_debug)
+    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.info(f"Generated C source code: {c_source_path}")
+    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_name}")
-        logger.debug(f"Module: {entry_module}")
-        logger.debug(f"Type: {loader_type}")
+        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:
@@ -1438,144 +1162,119 @@ def _generate_single_loader(
 
 
 def generate_loader_for_project(
+    project: Project,
     project_dir: Path,
-    project_info: ProjectInfo,
-    is_debug: bool = False,
-    compiler: str | None = None,
-) -> bool:
+    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)
-        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
+        debug: Whether to generate debug version
     """
-    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]}")
+    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 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} ---")
+    # 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
 
-        # 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}")
+    return True
 
-        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}")
+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
 
-    return all_success
+    projects = Solution.projects
+    if not projects:
+        logger.error("Failed to load project information")
 
+    success_count = 0
+    failed_projects: list[str] = []
 
-def main() -> int:
-    """Main entry point for pyloadergen.
+    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")
 
-    Returns:
-        Exit code (0 for success, 1 for failure)
-    """
-    parser = argparse.ArgumentParser(description="Generate Python loader executables for all projects in directory")
+    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)"
+        "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"
+        "--compiler",
+        help="Specify compiler to use. Examples: gcc, clang, cl, or full path like C:\\vc\\bin\\cl.exe",
     )
-    args = parser.parse_args()
-
-    if args.debug:
-        logger.setLevel(logging.DEBUG)
-
-    base_dir = Path(args.directory)
-    if not base_dir.is_dir():
-        logger.error(f"Directory does not exist: {base_dir}")
-        return 1
-
-    logger.info(f"Working directory: {base_dir}")
-
-    # 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
-
-    projects_data = load_projects_json(projects_json)
-    if not projects_data:
-        logger.error("Failed to load project information")
-        return 1
-
-    # Convert dict to ProjectInfo dataclasses
-    projects: dict[str, ProjectInfo] = {name: ProjectInfo.from_dict(name, data) for name, data in projects_data.items()}
-
-    logger.info(f"Found {len(projects)} project(s) to process")
-
-    # Generate loaders
-    total_start = time.perf_counter()
-    success_count = 0
-    failed_projects: list[str] = []
-    use_current_dir = len(projects) == 1
+    return parser.parse_args()
 
-    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
+def main():
+    """Main entry point for pyloadergen."""
+    args = parse_args()
 
-        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
+    if args.debug:
+        logger.setLevel(logging.DEBUG)
 
-    # 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")
+    working_dir = Path(args.directory)
+    if not working_dir.is_dir():
+        logger.error(f"Directory does not exist: {working_dir}")
+        return
 
-    return 0 if not failed_projects else 1
+    logger.info(f"Working directory: {working_dir}")
+    generate_loader(working_dir, args.debug)
 
 
 if __name__ == "__main__":
-    import sys
-
-    sys.exit(main())
+    main()