skeleton-framework 0.1.2__tar.gz → 0.1.4__tar.gz

{skeleton_framework-0.1.2 → skeleton_framework-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: skeleton-framework
-Version: 0.1.2
+Version: 0.1.4
 Summary: A full-stack app framework: Python orchestration + FastAPI + WebPack frontend.
 Author-email: lambdadotjoburg <lambdadotjoburg@gmail.com>
 License-Expression: LicenseRef-Proprietary
@@ -107,6 +107,23 @@ Skeleton also exposes the individual stages when you want to configure the appli
 
 ### 1. Generate configuration
 
+Generate the project configuration files before initialization.
+Skeleton supports React and SolidJS frontend profiles.
+
+Select the desired frontend framework using the `--config` command:
+
+```bash
+skeleton --config react
+```
+
+Or select SolidJS:
+
+```bash
+skeleton --config solid
+```
+
+If no framework is specified, React is selected by default:
+
 ```bash
 skeleton --config
 ```
@@ -400,7 +417,7 @@ source .venv/bin/activate
 From the test project directory:
 
 ```bash
-python -m pip install --force-reinstall ../framework/dist/skeleton_framework-0.1.2-py3-none-any.whl
+python -m pip install --force-reinstall ../framework/dist/skeleton_framework-0.1.3-py3-none-any.whl
 ```
 
 Adjust the relative path, wheel filename & version to match your framework checkout and build output.

{skeleton_framework-0.1.2 → skeleton_framework-0.1.4}/README.md

@@ -89,6 +89,23 @@ Skeleton also exposes the individual stages when you want to configure the appli
 
 ### 1. Generate configuration
 
+Generate the project configuration files before initialization.
+Skeleton supports React and SolidJS frontend profiles.
+
+Select the desired frontend framework using the `--config` command:
+
+```bash
+skeleton --config react
+```
+
+Or select SolidJS:
+
+```bash
+skeleton --config solid
+```
+
+If no framework is specified, React is selected by default:
+
 ```bash
 skeleton --config
 ```
@@ -382,7 +399,7 @@ source .venv/bin/activate
 From the test project directory:
 
 ```bash
-python -m pip install --force-reinstall ../framework/dist/skeleton_framework-0.1.2-py3-none-any.whl
+python -m pip install --force-reinstall ../framework/dist/skeleton_framework-0.1.3-py3-none-any.whl
 ```
 
 Adjust the relative path, wheel filename & version to match your framework checkout and build output.

{skeleton_framework-0.1.2 → skeleton_framework-0.1.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "skeleton-framework"
-version = "0.1.2"
+version = "0.1.4"
 description = "A full-stack app framework: Python orchestration + FastAPI + WebPack frontend."
 readme = "README.md"
 requires-python = ">=3.11"

{skeleton_framework-0.1.2 → skeleton_framework-0.1.4}/skeleton/cli.py

@@ -27,10 +27,15 @@ from pathlib import Path
 # ============================================================
 
 # skeleton --config
+# skeleton --config react
+# skeleton --config solid
+# skeleton --config vue
+
 # skeleton --init
 # skeleton --install
 # skeleton --start
 # skeleton --start frontend gateway --open
+
 # skeleton --quickstart
 
 # skeleton --serve

{skeleton_framework-0.1.2 → skeleton_framework-0.1.4}/skeleton/client.py

@@ -176,11 +176,13 @@ def main(
 
         from skeleton.infrastructure.bootstrap.src.config import config
 
+        framework = args[1] if len(args) > 1 else None
+
         config(
             framework_root=framework_root,
             project_root=project_root,
+            framework=framework,
         )
-
         return 0
 
     if command == "--init":

{skeleton_framework-0.1.2 → skeleton_framework-0.1.4}/skeleton/infrastructure/bootstrap/src/commands/client/init.py

@@ -362,6 +362,7 @@ def init(
         target=project_root,
         frontend=layout["frontend"],
         backend=layout["backend"],
+        framework_root=framework_root,
     )
 
     # ---------------------------------------------------------

skeleton_framework-0.1.4/skeleton/infrastructure/bootstrap/src/config.py

@@ -0,0 +1,151 @@
+import json, shutil
+from pathlib import Path
+
+SUPPORTED_FRAMEWORKS = {"react", "solid", "vue"}
+
+def read_json(path: Path) -> dict:
+    with path.open("r", encoding="utf-8") as file:
+        data = json.load(file)
+
+    if not isinstance(data, dict):
+        raise ValueError(f"Expected a JSON object: {path}")
+
+    return data
+
+def write_json(path: Path, data: dict) -> None:
+    with path.open("w", encoding="utf-8") as file:
+        json.dump(data, file, indent=4)
+        file.write("\n")
+
+def config(
+    framework_root: Path,
+    project_root: Path,
+    framework: str | None = None,
+) -> None:
+
+    templates_root = (
+        framework_root
+        / "skeleton"
+        / "infrastructure"
+        / "bootstrap"
+        / "src"
+        / "templates"
+    )
+
+    config_templates = templates_root / "config"
+    profiles_root = templates_root / "profiles"
+
+    if not config_templates.is_dir():
+        raise FileNotFoundError(
+            f"Configuration templates not found: {config_templates}"
+        )
+
+    if not profiles_root.is_dir():
+        raise FileNotFoundError(
+            f"Framework profiles not found: {profiles_root}"
+        )
+
+    if framework is not None:
+        framework = framework.strip().lower()
+
+        if framework not in SUPPORTED_FRAMEWORKS:
+            supported = ", ".join(sorted(SUPPORTED_FRAMEWORKS))
+            raise ValueError(
+                f"Unsupported frontend framework: {framework!r}. "
+                f"Choose one of: {supported}"
+            )
+
+    project_root = project_root.resolve()
+    project_root.mkdir(parents=True, exist_ok=True)
+
+    # ---------------------------------------------------------
+    # Copy shared project configuration.
+    # ---------------------------------------------------------
+
+    for template in config_templates.iterdir():
+        destination = project_root / template.name
+
+        if destination.exists():
+            print(f"INFO: Preserving existing file: {destination}")
+            continue
+
+        if template.is_dir():
+            shutil.copytree(template, destination)
+        else:
+            shutil.copy2(template, destination)
+
+        print(f"INFO: Created: {destination}")
+
+    # ---------------------------------------------------------
+    # Determine the selected framework.
+    # ---------------------------------------------------------
+
+    frontend_config_path = project_root / "skeleton-config.json"
+    dependencies_path = project_root / "skeleton-dependencies.json"
+
+    if framework is not None:
+        selected_framework = framework
+
+    elif frontend_config_path.is_file():
+        existing_config = read_json(frontend_config_path)
+        selected_framework = existing_config.get("framework", "react")
+
+        if (
+            not isinstance(selected_framework, str)
+            or selected_framework not in SUPPORTED_FRAMEWORKS
+        ):
+            raise ValueError(
+                f"Invalid framework in {frontend_config_path}: "
+                f"{selected_framework!r}"
+            )
+
+    else:
+        selected_framework = "react"
+
+    profile = profiles_root / selected_framework
+
+    if not profile.is_dir():
+        raise FileNotFoundError(
+            f"Framework profile not found: {profile}"
+        )
+
+    profile_config_path = profile / "skeleton-config.json"
+    profile_dependencies_path = profile / "skeleton-dependencies.json"
+
+    for path in (profile_config_path, profile_dependencies_path):
+        if not path.is_file():
+            raise FileNotFoundError(
+                f"Required framework profile file not found: {path}"
+            )
+
+    # Read and validate both profile files before writing either.
+    frontend_config = read_json(profile_config_path)
+    dependencies = read_json(profile_dependencies_path)
+
+    # Ensure the selected profile identifies itself correctly.
+    frontend_config["framework"] = selected_framework
+
+    # ---------------------------------------------------------
+    # Generate the root-level framework configuration.
+    # ---------------------------------------------------------
+
+    # Explicit selection resets both framework-managed files
+    # to the chosen profile defaults.
+    #
+    # Without an explicit selection, preserve existing files
+    # and create only files that are missing.
+
+    if framework is not None or not frontend_config_path.exists():
+        write_json(frontend_config_path, frontend_config)
+        print(f"INFO: Created/updated: {frontend_config_path}")
+    else:
+        print(f"INFO: Preserving existing file: {frontend_config_path}")
+
+    if framework is not None or not dependencies_path.exists():
+        write_json(dependencies_path, dependencies)
+        print(f"INFO: Created/updated: {dependencies_path}")
+    else:
+        print(f"INFO: Preserving existing file: {dependencies_path}")
+
+    print(f"INFO: Selected frontend framework: {selected_framework}")
+    print("INFO: Configuration complete")

skeleton_framework-0.1.4/skeleton/infrastructure/bootstrap/src/copy.py

@@ -0,0 +1,393 @@
+import json
+import shutil
+
+from pathlib import Path
+
+def copy_template(source: Path, target: Path) -> None:
+
+    target.mkdir(parents=True, exist_ok=True)
+
+    for item in source.iterdir():
+
+        destination = target / item.name
+
+        if destination.exists():
+
+            if item.is_dir() and destination.is_dir():
+                copy_template(item, destination)
+
+            continue
+
+        if item.is_dir():
+            shutil.copytree(item, destination)
+
+        else:
+            shutil.copy2(item, destination)
+
+def _copy_profile_entry_point(
+    framework_root: Path,
+    project_root: Path,
+    frontend: str,
+    config: dict,
+) -> None:
+    """Copy the selected framework's entry point into the client."""
+
+    framework = config.get("framework")
+
+    profile_filenames = {
+        "react": "main.tsx",
+        "solid": "main.tsx",
+        "vue": "main.ts",
+    }
+
+    if framework not in profile_filenames:
+        raise ValueError(
+            f"Unsupported frontend framework: {framework!r}"
+        )
+
+    entry = config.get("entry")
+    if not isinstance(entry, dict):
+        raise ValueError(
+            "skeleton-config.json: 'entry' must be an object."
+        )
+
+    entry_name = entry.get("main")
+    if not isinstance(entry_name, str) or not entry_name.strip():
+        raise ValueError(
+            "skeleton-config.json: 'entry.main' must be "
+            "a non-empty string."
+        )
+
+    source_name = profile_filenames[framework]
+
+    source = (
+        framework_root
+        / "skeleton"
+        / "infrastructure"
+        / "bootstrap"
+        / "src"
+        / "templates"
+        / "profiles"
+        / framework
+        / source_name
+    )
+
+    if not source.is_file():
+        raise FileNotFoundError(
+            f"Frontend entry-point template not found: {source}"
+        )
+
+    # entry.main is relative to the frontend source directory.
+    entry_path = Path(entry_name)
+
+    if entry_path.is_absolute() or ".." in entry_path.parts:
+        raise ValueError(
+            "skeleton-config.json: 'entry.main' must be a "
+            "relative path within the frontend source directory."
+        )
+
+    # If an extension is supplied, it must match the selected profile.
+    if entry_path.suffix and entry_path.suffix != source.suffix:
+        raise ValueError(
+            f"Entry point {entry_name!r} must use the "
+            f"{source.suffix} extension for {framework}."
+        )
+
+    if not entry_path.suffix:
+        entry_path = entry_path.with_suffix(source.suffix)
+
+    config_lib = config.get("lib")
+    if not isinstance(config_lib, dict):
+        raise ValueError(
+            "skeleton-config.json: 'lib' must be an object."
+        )
+
+    source_directory = config_lib.get("src", "src")
+    if (
+        not isinstance(source_directory, str)
+        or not source_directory.strip()
+    ):
+        raise ValueError(
+            "skeleton-config.json: 'lib.src' must be "
+            "a non-empty relative path."
+        )
+
+    source_path = Path(source_directory)
+    if source_path.is_absolute() or ".." in source_path.parts:
+        raise ValueError(
+            "skeleton-config.json: 'lib.src' must be a "
+            "relative path within the frontend directory."
+        )
+
+    frontend_root = project_root / frontend
+    if not frontend_root.is_dir():
+        raise FileNotFoundError(
+            f"Frontend directory not found: {frontend_root}"
+        )
+
+    destination_directory = frontend_root / source_path
+    destination = destination_directory / entry_path
+
+    # Preserve existing client code on repeated initialization.
+    if destination.exists():
+        print(
+            f"INFO: Preserving existing frontend entry point: "
+            f"{destination}"
+        )
+        return
+
+    destination_directory.mkdir(
+        parents=True,
+        exist_ok=True,
+    )
+
+    shutil.copy2(source, destination)
+
+    print(
+        f"INFO: Copied {framework} entry point: {destination}"
+    )
+
+def _copy_profile_files(
+    framework_root: Path,
+    project_root: Path,
+    frontend: str,
+    config: dict,
+) -> None:
+    """Copy additional source files required by the selected framework."""
+
+    framework = config.get("framework")
+
+    profile_files = {
+        "react": (),
+        "solid": (),
+        "vue": (
+            "App.vue",
+            "vue.d.ts",
+        ),
+    }
+
+    if framework not in profile_files:
+        raise ValueError(
+            f"Unsupported frontend framework: {framework!r}"
+        )
+
+    if not profile_files[framework]:
+        return
+
+    config_lib = config.get("lib")
+
+    if not isinstance(config_lib, dict):
+        raise ValueError(
+            "skeleton-config.json: 'lib' must be an object."
+        )
+
+    source_directory = config_lib.get("src", "src")
+
+    if (
+        not isinstance(source_directory, str)
+        or not source_directory.strip()
+    ):
+        raise ValueError(
+            "skeleton-config.json: 'lib.src' must be "
+            "a non-empty relative path."
+        )
+
+    source_path = Path(source_directory)
+
+    if source_path.is_absolute() or ".." in source_path.parts:
+        raise ValueError(
+            "skeleton-config.json: 'lib.src' must be a "
+            "relative path within the frontend directory."
+        )
+
+    profile = (
+        framework_root
+        / "skeleton"
+        / "infrastructure"
+        / "bootstrap"
+        / "src"
+        / "templates"
+        / "profiles"
+        / framework
+    )
+
+    destination_directory = (
+        project_root
+        / frontend
+        / source_path
+    )
+
+    destination_directory.mkdir(
+        parents=True,
+        exist_ok=True,
+    )
+
+    for filename in profile_files[framework]:
+
+        source = profile / filename
+        destination = destination_directory / filename
+
+        if not source.is_file():
+            raise FileNotFoundError(
+                f"Frontend profile template not found: {source}"
+            )
+
+        # Preserve client files on repeated initialization.
+        if destination.exists():
+            print(
+                f"INFO: Preserving existing frontend file: "
+                f"{destination}"
+            )
+            continue
+
+        shutil.copy2(
+            source,
+            destination,
+        )
+
+        print(
+            f"INFO: Copied {framework} profile file: "
+            f"{destination}"
+        )
+
+def copy_app_template(
+    source: Path,
+    target: Path,
+    frontend: str,
+    backend: str,
+    framework_root: Path,
+) -> None:
+
+    target.mkdir(parents=True, exist_ok=True)
+
+    directories = {
+        "frontend": frontend,
+        "backend": backend,
+    }
+
+    # ---------------------------------------------------------
+    # Copy the application templates.
+    # ---------------------------------------------------------
+
+    for item in source.iterdir():
+
+        name = directories.get(item.name, item.name)
+        destination = target / name
+
+        if destination.exists():
+
+            if item.is_dir() and destination.is_dir():
+                copy_template(item, destination)
+
+            continue
+
+        if item.is_dir():
+            shutil.copytree(item, destination)
+
+        else:
+            shutil.copy2(item, destination)
+
+    # ---------------------------------------------------------
+    # Read the selected frontend framework.
+    # ---------------------------------------------------------
+
+    config_path = target / "skeleton-config.json"
+
+    if not config_path.is_file():
+        raise FileNotFoundError(
+            f"Skeleton configuration not found: {config_path}. "
+            "Run 'skeleton --config' first."
+        )
+
+    with config_path.open(
+        "r",
+        encoding="utf-8",
+    ) as file:
+        config = json.load(file)
+
+    if not isinstance(config, dict):
+        raise ValueError(
+            f"Expected a JSON object: {config_path}"
+        )
+
+    framework = config.get("framework")
+
+    supported_frameworks = {
+        "react",
+        "solid",
+        "vue",
+    }
+
+    if framework not in supported_frameworks:
+        raise ValueError(
+            f"Unsupported frontend framework in {config_path}: "
+            f"{framework!r}. Choose one of: "
+            f"{', '.join(sorted(supported_frameworks))}"
+        )
+
+    # ---------------------------------------------------------
+    # Locate the selected profile's TypeScript configuration.
+    # ---------------------------------------------------------
+
+    profile_tsconfig = (
+        framework_root
+        / "skeleton"
+        / "infrastructure"
+        / "bootstrap"
+        / "src"
+        / "templates"
+        / "profiles"
+        / framework
+        / "tsconfig.json"
+    )
+
+    if not profile_tsconfig.is_file():
+        raise FileNotFoundError(
+            f"TypeScript configuration not found for "
+            f"framework {framework!r}: {profile_tsconfig}"
+        )
+
+    # ---------------------------------------------------------
+    # Copy tsconfig.json into the configured frontend directory.
+    # ---------------------------------------------------------
+
+    frontend_root = target / frontend
+
+    if not frontend_root.is_dir():
+        raise FileNotFoundError(
+            f"Frontend directory not found: {frontend_root}"
+        )
+
+    destination = frontend_root / "tsconfig.json"
+
+    shutil.copy2(
+        profile_tsconfig,
+        destination,
+    )
+
+    print(
+        f"INFO: Copied {framework} TypeScript configuration: "
+        f"{destination}"
+    )
+
+    # ---------------------------------------------------------
+    # Copy the selected profile's entry point.
+    # ---------------------------------------------------------
+
+    _copy_profile_entry_point(
+        framework_root=framework_root,
+        project_root=target,
+        frontend=frontend,
+        config=config,
+    )
+
+    # ---------------------------------------------------------
+    # Copy additional framework-specific source files.
+    # ---------------------------------------------------------
+
+    _copy_profile_files(
+        framework_root=framework_root,
+        project_root=target,
+        frontend=frontend,
+        config=config,
+    )

{skeleton_framework-0.1.2/skeleton/infrastructure/bootstrap/src/templates/app/frontend/src → skeleton_framework-0.1.4/skeleton/infrastructure/bootstrap/src/templates/profiles/react}/main.tsx

@@ -3,7 +3,7 @@ import { createRoot } from "react-dom/client";
 const body = document.querySelector("body");
 
 if (!body) {
-    throw new Error("Body element not found");
+    throw new Error("<body> element not found");
 }
 
 const root = document.createElement("div");