simple-module-cli 0.0.25__tar.gz → 0.0.27__tar.gz

{simple_module_cli-0.0.25 → simple_module_cli-0.0.27}/.gitignore

@@ -45,6 +45,7 @@ docs/.vitepress/dist/
 host/client_app/modules.manifest.json
 host/client_app/modules.generated.ts
 host/client_app/modules.generated.css
+host/client_app/modules.assets.json
 
 # Worktrees
 .worktrees/

{simple_module_cli-0.0.25 → simple_module_cli-0.0.27}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simple_module_cli
-Version: 0.0.25
+Version: 0.0.27
 Summary: Standalone scaffolder for the SimpleModule framework — `smpy new`, `smpy create-module`, plugin host.
 Project-URL: Homepage, https://github.com/antosubash/simple_module_python
 Project-URL: Repository, https://github.com/antosubash/simple_module_python

{simple_module_cli-0.0.25 → simple_module_cli-0.0.27}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "simple_module_cli"
-version = "0.0.25"
+version = "0.0.27"
 description = "Standalone scaffolder for the SimpleModule framework — `smpy new`, `smpy create-module`, plugin host."
 readme = "README.md"
 license = "MIT"

{simple_module_cli-0.0.25 → simple_module_cli-0.0.27}/simple_module_cli/catalog.py

@@ -57,6 +57,12 @@ CATALOG: dict[str, ModuleEntry] = {
         requires=("users",),
         recipe="background_tasks",
     ),
+    "site_lock": ModuleEntry(
+        "site_lock",
+        "simple_module_site_lock",
+        "Site Lock",
+        requires=("auth", "settings"),
+    ),
 }
 
 

simple_module_cli-0.0.27/simple_module_cli/templates/host/client_app/styles.css

@@ -0,0 +1,27 @@
+@import "@simple-module-py/ui/styles/globals.css";
+@import "./modules.generated.css";
+
+/* App-level source scanning — host code + workspace modules.
+ * Wheel-installed modules are covered by modules.generated.css.
+ *
+ * The module glob deliberately covers the whole package, not just pages/:
+ * shared components, hooks and Puck blocks carry Tailwind classes too, and
+ * scanning pages/ alone meant such a class only reached the bundle when some
+ * other scanned file happened to use it as well. The {ts,tsx} filter is what
+ * keeps .py files out of the scan. */
+@source "./**/*.{ts,tsx}";
+@source "../../modules/*/*/**/*.{ts,tsx}";
+/* The second `*` above matches any directory under modules/<name>/, not just
+ * the Python package — so a module's sibling tests/ would be scanned too and
+ * test-only classes would land in the production bundle.
+ *
+ * Consequence: a module's Python package must not itself be named `tests`
+ * (i.e. modules/tests/tests/), or this line would exclude the package too. No
+ * glob can tell a package directory from a sibling, and `tests` is not a
+ * viable package name anyway — it collides with pytest collection. */
+@source not "../../modules/*/tests/**";
+
+body {
+  margin: 0;
+  font-family: var(--font-sans, system-ui, -apple-system, sans-serif);
+}

{simple_module_cli-0.0.25 → simple_module_cli-0.0.27}/simple_module_cli/templates/host/client_app/vite.config.ts

@@ -68,6 +68,37 @@ if (fs.existsSync(manifestPath)) {
     }
   }
 }
+
+// Per-module aliases, so generated CSS can say
+//   @import "#module/gis/styles.css"
+// instead of a ../../../.venv/lib/python3.12/site-packages/gis/styles.css
+// path that breaks the moment the interpreter version changes.
+//
+// `@tailwindcss/vite` builds its CSS import resolver with
+// `createResolver({ ...config.resolve, ... })`, so `resolve.alias` governs
+// CSS `@import` as well as JS — verified against @tailwindcss/vite 4.2.4.
+//
+// Read from modules.assets.json rather than modules.manifest.json: the
+// manifest is keyed off `pages/`, so a module shipping only CSS never
+// appears in it.
+type ModuleAsset = { package_name: string; package: string };
+const moduleAliases: { find: string; replacement: string }[] = [];
+const assetsPath = path.resolve(__dirname, 'modules.assets.json');
+let moduleAssets: Record<string, ModuleAsset> = {};
+try {
+  moduleAssets = JSON.parse(fs.readFileSync(assetsPath, 'utf-8'));
+} catch {
+  // Absent until `smpy gen-pages` runs — proceed with no aliases.
+}
+for (const entry of Object.values(moduleAssets)) {
+  moduleAliases.push({ find: `#module/${entry.package_name}`, replacement: entry.package });
+  if (!moduleFsAllow.includes(entry.package)) moduleFsAllow.push(entry.package);
+}
+// Keep the alias list in a stable, longest-first order. Vite matches a string
+// `find` on exact equality or a `/`-bounded prefix, so `#module/gis` could not
+// swallow `#module/gis_extra` in any order — this is just determinism, not a
+// correctness fix.
+moduleAliases.sort((a, b) => b.find.length - a.find.length);
 const fakeWorkspaceImporter = path.join(fsRoot, 'package.json');
 
 // CJS-only deps like `clsx`, `tailwind-merge`, `class-variance-authority`
@@ -200,6 +231,9 @@ export default defineConfig({
   plugins: [moduleBareImportResolver(), react(), tailwindcss()],
   root: __dirname,
   resolve: {
+    // `#module/<pkg>` -> that module's package directory. Consumed by the
+    // @import lines in modules.generated.css.
+    alias: moduleAliases,
     dedupe: [...REACT_CORE_DEPS, '@simple-module-py/ui', '@simple-module-py/i18n'],
   },
   optimizeDeps: {

{simple_module_cli-0.0.25 → simple_module_cli-0.0.27}/simple_module_cli/templates/module/README.md.tpl

@@ -39,6 +39,24 @@ Hosts mount the bundle automatically at
 when it exists, an empty dict otherwise (so dev without a build step
 doesn't fail).
 
+## Styling (optional)
+
+This module can ship CSS that lands in the host's Tailwind build with no
+wiring on the host side. Create either file beside `pages/` and it is
+picked up automatically — the scaffold deliberately does not create them
+empty, since a file that is always imported but usually empty is noise:
+
+- `{{PACKAGE_NAME}}/theme.css` — `@theme` tokens, `@custom-variant`,
+  `@font-face`. Imported **unlayered**, because a `@theme` block inside a
+  cascade layer registers nothing.
+- `{{PACKAGE_NAME}}/styles.css` — component rules, keyframes, vendor CSS.
+  Imported into **`layer(components)`**, so these rules always lose to a
+  Tailwind utility and a consuming app can still override them.
+
+Putting a construct in the wrong file builds fine but cascades in a way you
+probably did not intend, so `make doctor` warns: `SM022` for `@theme` in
+`styles.css`, `SM023` for an unlayered rule in `theme.css`.
+
 ## Continuous integration
 
 Two workflows live under `.github/workflows/`:

{simple_module_cli-0.0.25 → simple_module_cli-0.0.27}/simple_module_cli/templates/module/tsconfig.json.tpl

@@ -1,7 +1,6 @@
 {
   "extends": "@simple-module-py/tsconfig/base.json",
   "compilerOptions": {
-    "baseUrl": ".",
     "paths": {
       "@/*": ["./{{PACKAGE_NAME}}/*"],
       "@simple-module-py/ui/*": ["../../packages/ui/src/*"]

{simple_module_cli-0.0.25 → simple_module_cli-0.0.27}/tests/test_cli_wizard.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import typer
+from simple_module_cli.catalog import CATALOG
 from simple_module_cli.wizard import run_wizard
 from typer.testing import CliRunner
 
@@ -52,7 +53,12 @@ def test_wizard_full_preset_includes_background_tasks() -> None:
 
 
 def test_wizard_custom_picks_only_yes_answers() -> None:
-    answers = ["", "", "4"] + ["n"] * 7 + ["y", ""]
+    # The custom path prompts once per catalog module, in CATALOG order.
+    # Derive the answers from CATALOG rather than hardcoding a count: a
+    # hardcoded sequence silently shifts onto the wrong module the next time
+    # one is added, which is how this test broke when `site_lock` landed.
+    picks = ["y" if name == "background_tasks" else "n" for name in CATALOG]
+    answers = ["", "", "4", *picks, ""]
     _, _, selected, out = _drive(answers)
     assert set(selected) == {"background_tasks", "users", "auth"}
     assert "Added users (required by background_tasks)" in out

simple_module_cli-0.0.27/tests/test_module_css_assets.py

@@ -0,0 +1,223 @@
+"""Tests for module CSS asset discovery and emission (`smpy gen-pages`)."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+
+def _make_importable_module(tmp_path: Path, pkg_name: str, klass_name: str):
+    """Create a real importable package on disk and return a ModuleBase bound to it.
+
+    ``get_module_package_name`` derives the package from the class's
+    ``__module__``, and ``compute_module_assets`` then resolves that package
+    via ``importlib.resources.files``. So the package has to genuinely exist
+    on ``sys.path`` — a mock won't exercise the code path we care about.
+    """
+    from simple_module_core import ModuleBase, ModuleMeta
+
+    pkg = tmp_path / pkg_name
+    pkg.mkdir(parents=True, exist_ok=True)
+    (pkg / "__init__.py").write_text("", encoding="utf-8")
+    if str(tmp_path) not in sys.path:
+        sys.path.insert(0, str(tmp_path))
+    sys.modules.pop(pkg_name, None)
+
+    klass = type(
+        klass_name,
+        (ModuleBase,),
+        {"meta": ModuleMeta(name=klass_name), "__module__": f"{pkg_name}.module"},
+    )
+    return klass(), pkg
+
+
+class TestComputeModuleAssets:
+    async def test_detects_theme_and_styles(self, tmp_path):
+        """A module shipping theme.css/styles.css has both detected."""
+        from simple_module_hosting.assets import compute_module_assets
+
+        mod, pkg = _make_importable_module(tmp_path, "styled_mod", "Styled")
+        (pkg / "pages").mkdir()
+        (pkg / "theme.css").write_text("@theme { --color-x: red; }\n", encoding="utf-8")
+        (pkg / "styles.css").write_text(".x { color: red; }\n", encoding="utf-8")
+
+        result = compute_module_assets([mod])
+
+        assert len(result) == 1
+        entry = result[0]
+        assert entry.package_name == "styled_mod"
+        assert entry.theme_css is not None and entry.theme_css.name == "theme.css"
+        assert entry.styles_css is not None and entry.styles_css.name == "styles.css"
+        assert entry.pages_dir is not None
+
+    async def test_css_only_module_is_included(self, tmp_path):
+        """A module with CSS but no pages/ still appears — the manifest.json gap."""
+        from simple_module_hosting.assets import compute_module_assets
+
+        mod, pkg = _make_importable_module(tmp_path, "cssonly_mod", "CssOnly")
+        (pkg / "styles.css").write_text(".y { color: blue; }\n", encoding="utf-8")
+
+        result = compute_module_assets([mod])
+
+        assert [e.name for e in result] == ["CssOnly"]
+        assert result[0].pages_dir is None
+        assert result[0].theme_css is None
+        assert result[0].styles_css is not None
+
+    async def test_module_with_no_assets_is_omitted(self, tmp_path):
+        """A module contributing nothing frontend-ish is skipped, not an error."""
+        from simple_module_hosting.assets import compute_module_assets
+
+        mod, _pkg = _make_importable_module(tmp_path, "headless_mod", "Headless")
+
+        assert compute_module_assets([mod]) == []
+
+    async def test_preserves_discovery_order(self):
+        """Order follows discover_modules() (topological), not alphabetical."""
+        from simple_module_core import discover_modules
+        from simple_module_hosting.assets import compute_module_assets
+
+        modules = discover_modules()
+        result = compute_module_assets(modules)
+
+        names = [e.name for e in result]
+        discovery_order = [m.meta.name for m in modules]
+        assert names == [n for n in discovery_order if n in set(names)]
+
+
+def _assets(tmp_path: Path, **overrides):
+    """Build a single ModuleAssets entry with sensible defaults."""
+    from simple_module_hosting.assets import ModuleAssets
+
+    defaults = {
+        "name": "Gis",
+        "package_name": "gis",
+        "package_dir": tmp_path / "gis",
+        "pages_dir": None,
+        "theme_css": None,
+        "styles_css": None,
+    }
+    return ModuleAssets(**{**defaults, **overrides})
+
+
+class TestCssEmission:
+    async def test_styles_layered_theme_unlayered(self, tmp_path):
+        """theme.css imports unlayered; styles.css imports into layer(components)."""
+        from simple_module_hosting.assets import render_modules_css
+
+        entry = _assets(
+            tmp_path,
+            theme_css=tmp_path / "gis" / "theme.css",
+            styles_css=tmp_path / "gis" / "styles.css",
+        )
+        css = render_modules_css([entry], in_repo=lambda _p: False)
+
+        assert '@import "#module/gis/theme.css";' in css
+        assert '@import "#module/gis/styles.css" layer(components);' in css
+        # Tokens must be declared before the rules that consume them.
+        assert css.index("theme.css") < css.index("styles.css")
+
+    async def test_source_skips_in_repo_but_import_does_not(self, tmp_path):
+        """@source is wheel-only; @import is emitted for every module."""
+        from simple_module_hosting.assets import render_modules_css
+
+        entry = _assets(
+            tmp_path,
+            name="Local",
+            package_name="local",
+            pages_dir=tmp_path / "local" / "pages",
+            styles_css=tmp_path / "local" / "styles.css",
+        )
+        css = render_modules_css([entry], in_repo=lambda _p: True)
+
+        assert "@source" not in css, "in-repo pages are covered by the static glob"
+        assert '@import "#module/local/styles.css" layer(components);' in css
+
+    async def test_source_emitted_for_wheel_modules(self, tmp_path):
+        """A wheel-installed module gets an absolute @source glob."""
+        from simple_module_hosting.assets import render_modules_css
+
+        pages = tmp_path / "gis" / "pages"
+        css = render_modules_css([_assets(tmp_path, pages_dir=pages)], in_repo=lambda _p: False)
+
+        assert f'@source "{pages.as_posix()}/**/*.{{ts,tsx}}";' in css
+
+    async def test_module_without_css_emits_no_import(self, tmp_path):
+        """Pages-only modules contribute @source but no @import."""
+        from simple_module_hosting.assets import render_modules_css
+
+        entry = _assets(tmp_path, pages_dir=tmp_path / "gis" / "pages")
+        css = render_modules_css([entry], in_repo=lambda _p: False)
+
+        assert "@import" not in css
+
+    async def test_output_is_formatter_clean(self, tmp_path):
+        """No doubled blank lines, exactly one trailing newline.
+
+        `biome ci .` lints the whole tree, and `modules.generated.css` is
+        untracked but not exempt — so a stray blank line here fails `make lint`
+        for anyone who has run `gen-pages`.
+        """
+        from simple_module_hosting.assets import render_modules_css
+
+        for entry in (
+            _assets(tmp_path, styles_css=tmp_path / "gis" / "styles.css"),
+            _assets(tmp_path, pages_dir=tmp_path / "gis" / "pages"),
+        ):
+            css = render_modules_css([entry], in_repo=lambda _p: False)
+            assert "\n\n\n" not in css, f"doubled blank line in:\n{css!r}"
+            assert css.endswith("\n") and not css.endswith("\n\n"), repr(css[-20:])
+
+        empty = render_modules_css([], in_repo=lambda _p: False)
+        assert "\n\n\n" not in empty and empty.endswith("\n")
+
+    async def test_no_relative_paths_anywhere(self, tmp_path):
+        """The whole point of aliases: generated @import lines never use ../.."""
+        from simple_module_core import discover_modules
+        from simple_module_hosting.manifest import write_module_pages_manifest
+
+        written = write_module_pages_manifest(discover_modules(), tmp_path)
+        css = written["css"].read_text(encoding="utf-8")
+
+        for line in css.splitlines():
+            if line.startswith("@import"):
+                assert "../" not in line, f"@import must not use a relative path: {line}"
+                assert '"#module/' in line, f"@import must use the alias prefix: {line}"
+
+
+class TestAssetsManifest:
+    async def test_writes_assets_json(self, tmp_path):
+        """modules.assets.json is emitted alongside the existing three files."""
+        import json
+
+        from simple_module_core import discover_modules
+        from simple_module_hosting.manifest import write_module_pages_manifest
+
+        written = write_module_pages_manifest(discover_modules(), tmp_path)
+
+        assets_path = tmp_path / "modules.assets.json"
+        assert assets_path.is_file()
+        assert written["assets"] == assets_path
+
+        data = json.loads(assets_path.read_text(encoding="utf-8"))
+        entry = data["Dashboard"]
+        assert entry["package_name"] == "dashboard"
+        assert entry["package"].endswith("dashboard")
+        assert set(entry) == {"package_name", "package", "pages", "theme", "styles"}
+
+    async def test_manifest_json_shape_unchanged(self, tmp_path):
+        """modules.manifest.json stays {name: pages_dir} for downstream vite configs.
+
+        Every downstream app holds its own copy of vite.config.ts and reads
+        this file; changing its value shape would break them all at once.
+        """
+        import json
+
+        from simple_module_core import discover_modules
+        from simple_module_hosting.manifest import write_module_pages_manifest
+
+        write_module_pages_manifest(discover_modules(), tmp_path)
+
+        data = json.loads((tmp_path / "modules.manifest.json").read_text(encoding="utf-8"))
+        assert data, "manifest should not be empty"
+        assert all(isinstance(v, str) for v in data.values())

simple_module_cli-0.0.27/tests/test_module_css_build.py

@@ -0,0 +1,72 @@
+"""Proves module-shipped CSS survives a real Tailwind build.
+
+Every unit test around `render_modules_css` can stay green while Tailwind
+emits nothing at all — the generated `@import` only pays off if Vite resolves
+the `#module/<pkg>` alias and Tailwind keeps the rule. This is the one
+assertion that exercises that whole chain, so it drives a genuine build
+rather than inspecting the generated text.
+
+Skipped where a build is impossible: CI's `python-tests` job installs Python
+deps only (`make install-py`), so `node_modules` is absent there. The JS jobs
+and local runs do have it.
+"""
+
+from __future__ import annotations
+
+import shutil
+import subprocess
+from pathlib import Path
+
+import pytest
+
+REPO_ROOT = Path(__file__).resolve().parents[3]
+
+pytestmark = [
+    pytest.mark.skipif(
+        not (REPO_ROOT / "node_modules").is_dir(),
+        reason="node_modules absent — run `npm install` to exercise the real build",
+    ),
+    pytest.mark.skipif(shutil.which("npm") is None, reason="npm not on PATH"),
+]
+
+
+class TestModuleCssReachesBundle:
+    def test_module_class_is_emitted_by_vite_build(self):
+        """A class defined only in a module's styles.css appears in the built CSS.
+
+        `.dashboard-stat-grid` is declared in modules/dashboard/dashboard/styles.css
+        and referenced by no TSX anywhere, so it can only reach the bundle via the
+        generated `@import "#module/dashboard/styles.css"`.
+        """
+        subprocess.run(
+            [
+                "uv",
+                "run",
+                "--project",
+                "host",
+                "smpy",
+                "host",
+                "gen-pages",
+                "--host-dir=host/client_app",
+            ],
+            cwd=REPO_ROOT,
+            check=True,
+            capture_output=True,
+        )
+
+        generated = (REPO_ROOT / "host/client_app/modules.generated.css").read_text(
+            encoding="utf-8"
+        )
+        assert '@import "#module/dashboard/styles.css" layer(components);' in generated, (
+            f"gen-pages did not emit the dashboard stylesheet import:\n{generated}"
+        )
+
+        subprocess.run(["npm", "run", "build"], cwd=REPO_ROOT, check=True, capture_output=True)
+
+        built = list((REPO_ROOT / "host/static/dist/assets").glob("*.css"))
+        assert built, "no CSS emitted by the build"
+        combined = "\n".join(p.read_text(encoding="utf-8") for p in built)
+        assert "dashboard-stat-grid" in combined, (
+            "module-shipped CSS did not reach the bundle — the #module alias "
+            "most likely failed to resolve"
+        )

{simple_module_cli-0.0.25 → simple_module_cli-0.0.27}/tests/test_module_pages_manifest.py

@@ -33,7 +33,7 @@ class TestModulePagesManifest:
         assert "Headless" not in result
 
     async def test_write_manifest_emits_json_and_ts(self, tmp_path):
-        """write_module_pages_manifest emits the JSON manifest, TS glob, and Tailwind CSS files."""
+        """write_module_pages_manifest emits the JSON manifest, TS glob, CSS and assets files."""
         import json
 
         from simple_module_core import discover_modules
@@ -45,10 +45,17 @@ class TestModulePagesManifest:
         manifest = tmp_path / "modules.manifest.json"
         generated = tmp_path / "modules.generated.ts"
         css = tmp_path / "modules.generated.css"
+        assets = tmp_path / "modules.assets.json"
         assert manifest.is_file()
         assert generated.is_file()
         assert css.is_file()
-        assert written == {"manifest": manifest, "generated": generated, "css": css}
+        assert assets.is_file()
+        assert written == {
+            "manifest": manifest,
+            "generated": generated,
+            "css": css,
+            "assets": assets,
+        }
 
         data = json.loads(manifest.read_text(encoding="utf-8"))
         assert "Dashboard" in data

simple_module_cli-0.0.25/simple_module_cli/templates/host/client_app/styles.css

@@ -1,12 +0,0 @@
-@import "@simple-module-py/ui/styles/globals.css";
-@import "./modules.generated.css";
-
-/* App-level source scanning — host code + workspace module pages.
- * Wheel-installed modules are covered by modules.generated.css. */
-@source "./**/*.{ts,tsx}";
-@source "../../modules/*/*/pages/**/*.{ts,tsx}";
-
-body {
-  margin: 0;
-  font-family: var(--font-sans, system-ui, -apple-system, sans-serif);
-}