jac-client 0.2.8__py3-none-any.whl → 0.2.9__py3-none-any.whl

jac_client/plugin/plugin_config.jac

@@ -5,10 +5,13 @@ configuration system, registering:
 - Plugin metadata (name, version)
 - Config schema for [plugins.client] section
 - npm dependency type for [dependencies.npm] section
+- Project templates (client, fullstack)
 """
 
+import os;
 import subprocess;
 import sys;
+import json;
 import from pathlib { Path }
 import from typing { Any }
 import from jaclang.pycore.runtime { hookimpl }
@@ -68,6 +71,11 @@ class JacClientPluginConfig {
                     "type": "dict",
                     "default": {},
                     "description": "TypeScript configuration overrides"
+                },
+                "configs": {
+                    "type": "dict",
+                    "default": {},
+                    "description": "Generate config files for npm packages. Keys are config names (e.g., 'postcss', 'tailwind'), values are the config objects to export."
                 }
             }
         };
@@ -79,15 +87,222 @@ class JacClientPluginConfig {
         return {
             "name": "npm",
             "dev_name": "npm.dev",
-            "cli_flag": "--cl",
+            "cli_flag": "--npm",
             "install_dir": ".jac/client/configs",
             "install_handler": _npm_install_handler,
             "install_all_handler": _npm_install_all_handler,
             "remove_handler": _npm_remove_handler
         };
     }
+
+    """Register the client and fullstack project templates."""
+    @hookimpl
+    static def register_project_template -> list[dict[str, Any]] {
+        templates: list[dict[str, Any]] = [];
+
+        # Load templates from bundled JSON files
+        for template_name in ["client", "fullstack"] {
+            template = _load_template(template_name);
+            if template {
+                templates.append(template);
+            }
+        }
+
+        return templates;
+    }
+}
+
+# ===============================================================================
+# Template Loader
+# ===============================================================================
+"""Load a template from bundled JSON file."""
+def _load_template(template_name: str) -> dict[str, Any] | None {
+    # Find the template JSON file relative to this module
+    # plugin_config.jac is in jac_client/plugin/, so .parent.parent = jac_client/
+    module_dir = Path(__file__).parent.parent;  # jac_client directory
+    template_path = module_dir / "templates" / f"{template_name}.jacpack";
+
+    if not template_path.exists() {
+        # Fallback: look in installed package location
+        import from importlib.resources { files }
+        try {
+            package_files = files("jac_client");
+            template_path = Path(str(package_files)) / "templates" / f"{template_name}.jacpack";
+        } except Exception {
+            return None;
+        }
+    }
+
+    if not template_path.exists() {
+        return None;
+    }
+
+    try {
+        with open(template_path, "r") as f {
+            data = json.load(f);
+        }
+
+        # Attach the post_create hook
+        data["post_create"] = _post_create_client;
+
+        return data;
+    } except Exception as e {
+        print(
+            f"Warning: Could not load {template_name} template: {e}", file=sys.stderr
+        );
+        return None;
+    }
+}
+
+# ===============================================================================
+# Post-create Hook for Client Template
+# ===============================================================================
+"""Post-create hook to ensure Node.js is installed and optionally install npm packages."""
+def _post_create_client(project_path: Path, project_name: str) -> None {
+    import from jac_client.plugin.src.vite_bundler { ViteBundler }
+    import from jac_client.plugin.utils.node_installer { NodeInstaller }
+    import from jaclang.cli.console { console }
+    import shutil;
+
+    # First, ensure Node.js is installed
+    console.print();
+    with console.status(
+        "[cyan]Checking Node.js installation...[/cyan]", spinner="dots"
+    ) as status {
+        node_result = NodeInstaller.ensure_node_installed(interactive=True);
+        node_installed = node_result[0];
+        message = node_result[1];
+        was_just_installed = node_result[2];
+    }
+
+    if not node_installed {
+        console.warning(f"Node.js is required for client development");
+        console.print(f"\n  {message}", file=sys.stderr);
+        console.print(
+            "  After installing Node.js, run: jac add --cl\n",
+            style="muted",
+            file=sys.stderr
+        );
+        return;
+    }
+
+    console.print(f"  ✔ {message}", style="success");
+
+    # Check if npm package installation should be skipped
+    if os.environ.get("JAC_CLIENT_SKIP_NPM_INSTALL") {
+        console.print(
+            "\n  ⏭ Skipping npm package installation (JAC_CLIENT_SKIP_NPM_INSTALL is set)",
+            style="muted"
+        );
+        console.print(
+            "  Run 'jac add --npm' when ready to install packages.\n", style="muted"
+        );
+        return;
+    }
+
+    console.print();
+
+    try {
+        # Verify jac.toml exists
+        toml_path = project_path / "jac.toml";
+        if not toml_path.exists() {
+            print(
+                "Warning: jac.toml not found, skipping package installation",
+                file=sys.stderr
+            );
+            return;
+        }
+
+        # Create ViteBundler instance
+        bundler = ViteBundler(project_path);
+
+        # Generate package.json with default packages
+        bundler.create_package_json(project_name=project_name);
+
+        # Ensure .jac/client directory exists
+        client_dir = bundler._get_client_dir();
+        client_dir.mkdir(parents=True, exist_ok=True);
+
+        # Copy package.json to .jac/client/ for npm install
+        configs_package_json = client_dir / 'configs' / 'package.json';
+        build_package_json = client_dir / 'package.json';
+
+        if not configs_package_json.exists() {
+            print(
+                "Warning: package.json was not generated, skipping package installation",
+                file=sys.stderr
+            );
+            return;
+        }
+
+        shutil.copy2(configs_package_json, build_package_json);
+
+        # Run npm install using NodeInstaller to handle NVM environment
+        try {
+            console.print("  Installing npm packages...", style="cyan");
+            with console.status(
+                "[cyan]Installing npm packages...[/cyan]", spinner="dots"
+            ) as status {
+                NodeInstaller.run_npm_with_nvm(
+                    ['install'], cwd=client_dir, timeout=300
+                );
+            }
+
+            # Move package-lock.json to configs/ if it was created
+            build_package_lock = client_dir / 'package-lock.json';
+            configs_package_lock = client_dir / 'configs' / 'package-lock.json';
+            if build_package_lock.exists() {
+                if configs_package_lock.exists() {
+                    configs_package_lock.unlink();
+                }
+                shutil.move(str(build_package_lock), str(configs_package_lock));
+            }
+
+            console.print("  ✔ npm packages installed", style="success");
+        } except subprocess.CalledProcessError as e {
+            console.warning(f"Failed to install packages: {e.stderr}");
+            console.print(
+                "  💡 You can install packages later with: jac add --cl\n",
+                style="muted"
+            );
+        } except FileNotFoundError {
+            console.warning(
+                "npm command not found. This may require reloading your shell."
+            );
+            console.print(
+                "  💡 You can install packages later with: jac add --cl\n",
+                style="muted"
+            );
+        } finally {
+            # Clean up temporary package.json
+            if build_package_json.exists() {
+                build_package_json.unlink();
+            }
+        }
+    } except Exception as e {
+        console.warning(f"Could not install default packages: {e}");
+        console.print(
+            "  💡 You can install packages later with: jac add --cl\n", style="muted"
+        );
+    }
+
+    # If Node.js was just installed, offer to restart terminal for full integration
+    if was_just_installed {
+        console.print();
+        console.info("Node.js was just installed via NVM");
+        console.print(
+            "\n  For Node.js to be available in your current shell:", style="muted"
+        );
+        console.print("    1. Run: source ~/.nvm/nvm.sh", style="muted");
+        console.print("    2. Or restart your terminal", style="muted");
+        console.print("\n  💡 npm commands from jac work immediately", style="info");
+        console.print();
+    }
 }
 
+# ===============================================================================
+# NPM Dependency Handlers
+# ===============================================================================
 """Install an npm package."""
 def _npm_install_handler(
     config: JacConfig,
@@ -101,15 +316,13 @@ def _npm_install_handler(
         raise RuntimeError("No project root found") ;
     }
 
-    project_dir = config.project_root;
-
     # Add to config (core JacConfig handles this)
-    package_version = version or "latest";
+    package_version: str = version or "latest";
     config.add_dependency(package_name, package_version, dev=is_dev, dep_type="npm");
     config.save();
 
     # Generate package.json and run npm install
-    _regenerate_and_install(project_dir);
+    _regenerate_and_install(Path(str(config.project_root)));
 }
 
 """Install all npm packages from jac.toml."""
@@ -118,7 +331,7 @@ def _npm_install_all_handler(config: JacConfig) -> None {
         raise RuntimeError("No project root found") ;
     }
 
-    _regenerate_and_install(config.project_root);
+    _regenerate_and_install(Path(str(config.project_root)));
 }
 
 """Remove an npm package."""
@@ -129,7 +342,7 @@ def _npm_remove_handler(
         raise RuntimeError("No project root found") ;
     }
 
-    project_dir = config.project_root;
+    project_dir: Path = Path(str(config.project_root));
 
     # Remove from config (core JacConfig handles this)
     result = config.remove_dependency(package_name, dev=is_dev, dep_type="npm");
@@ -147,8 +360,28 @@ def _npm_remove_handler(
 """Regenerate package.json from jac.toml and run npm install."""
 def _regenerate_and_install(project_dir: Path) -> None {
     import from jac_client.plugin.src.vite_bundler { ViteBundler }
+    import from jac_client.plugin.utils.node_installer { NodeInstaller }
     import shutil;
 
+    # Ensure Node.js is installed before proceeding
+    node_result = NodeInstaller.ensure_node_installed(interactive=True);
+    node_installed = node_result[0];
+    message = node_result[1];
+    was_just_installed = node_result[2];
+
+    if not node_installed {
+        raise RuntimeError(
+            f"Node.js installation required:\n{message}\n" + "Please install Node.js and try again."
+        ) ;
+    }
+
+    # Inform user if Node.js was just installed
+    if was_just_installed {
+        print(
+            "\nNote: Node.js was just installed. npm commands will work via NVM sourcing."
+        );
+    }
+
     bundler = ViteBundler(project_dir);
     bundler.create_package_json();
 
@@ -164,18 +397,13 @@ def _regenerate_and_install(project_dir: Path) -> None {
     }
 
     try {
-        subprocess.run(
-            ["npm", "install"],
-            cwd=client_dir,
-            check=True,
-            capture_output=True,
-            text=True
-        );
+        # Use NodeInstaller.run_npm_with_nvm to handle NVM environment
+        NodeInstaller.run_npm_with_nvm(["install"], cwd=client_dir, timeout=300);
     } except subprocess.CalledProcessError as e {
         raise RuntimeError(f"Failed to install npm packages: {e.stderr}") from e ;
     } except FileNotFoundError {
         raise RuntimeError(
-            "npm command not found. Ensure Node.js and npm are installed."
+            "npm command not found. This may require reloading your shell after Node.js installation."
         ) from None ;
     } finally {
         # Clean up temporary package.json

jac_client/plugin/src/config_loader.jac

@@ -21,6 +21,7 @@ class JacClientConfig(PluginConfigBase) {
     def save(self: JacClientConfig) -> None;
     def get_vite_config(self: JacClientConfig) -> dict[str, Any];
     def get_ts_config(self: JacClientConfig) -> dict[str, Any];
+    def get_configs(self: JacClientConfig) -> dict[str, Any];
     def get_package_config(self: JacClientConfig) -> dict[str, Any];
     def add_dependency(
         self: JacClientConfig, name: str, version: str, is_dev: bool = False

jac_client/plugin/src/impl/compiler.impl.jac

@@ -49,7 +49,7 @@ impl ViteCompiler.create_entry_file(self: ViteCompiler, module_path: Path) -> No
     entry_file = self.compiled_dir / '_entry.js';
     # Derive the app module filename from the entry point (e.g., main.jac -> main.js, app.jac -> app.js)
     app_module_name = module_path.stem;
-    entry_content = f'import React from "react";\nimport {{ createRoot }} from "react-dom/client";\nimport {{ app as App }} from "./{app_module_name}.js";\n\nconst root = createRoot(document.getElementById("root"));\nroot.render(React.createElement(App, null));\n';
+    entry_content = f'import React from "react";\nimport {{ createRoot }} from "react-dom/client";\nimport {{ app as App }} from "./{app_module_name}.js";\nimport {{ JacClientErrorBoundary, ErrorFallback }} from "@jac-client/utils";\n\nconst root = createRoot(document.getElementById("root"));\nroot.render(\n\tReact.createElement(\n\t\tJacClientErrorBoundary,{{ FallbackComponent: ErrorFallback }},\n\t\tReact.createElement(App, null)\n\t)\n);\n';
     entry_file.write_text(entry_content, encoding='utf-8');
 }
 

jac_client/plugin/src/impl/config_loader.impl.jac

@@ -27,6 +27,7 @@ impl JacClientConfig.get_default_config(self: JacClientConfig) -> dict[str, Any]
             'resolve': {}
         },
         'ts': {'compilerOptions': {}, 'include': [], 'exclude': []},
+        'configs': {},  # Generic config file generation: { "postcss": {...}, "tailwind": {...} }
         'package': {
             'name': '',
             'version': '1.0.0',
@@ -61,6 +62,7 @@ impl JacClientConfig.load(self: JacClientConfig) -> dict[str, Any] {
     user_config: dict[str, Any] = {
         'vite': client_config.get('vite', {}),
         'ts': client_config.get('ts', {}),
+        'configs': client_config.get('configs', {}),
         'package': {
             'name': jac_config.project.name,
             'version': jac_config.project.version,
@@ -91,6 +93,12 @@ impl JacClientConfig.get_ts_config(self: JacClientConfig) -> dict[str, Any] {
     return config.get('ts', {});
 }
 
+"""Get generic config files to generate (postcss, tailwind, etc.)."""
+impl JacClientConfig.get_configs(self: JacClientConfig) -> dict[str, Any] {
+    config = self.load();
+    return config.get('configs', {});
+}
+
 """Save configuration back to jac.toml using core JacConfig."""
 impl JacClientConfig.save(self: JacClientConfig) -> None {
     jac_config = self.get_jac_config();

jac_client/plugin/src/impl/vite_bundler.impl.jac

@@ -78,6 +78,8 @@ impl ViteBundler.create_package_json(
     }
     # Generate tsconfig.json during build time
     self.create_tsconfig();
+    # Generate config files (postcss, tailwind, etc.) from jac.toml
+    self.create_config_files();
     return package_json_path;
 }
 
@@ -375,6 +377,8 @@ impl ViteBundler.find_bundle(self: ViteBundler) -> Optional[Path] {
 
 """Run Vite build with generated config in .jac/client/configs/."""
 impl ViteBundler.build(self: ViteBundler, entry_file: Optional[Path] = None) -> None {
+    import sys;
+    import time;
     self.output_dir.mkdir(parents=True, exist_ok=True);
     generated_package_json = self._get_client_dir() / 'configs' / 'package.json';
     if not generated_package_json.exists() {
@@ -395,18 +399,31 @@ impl ViteBundler.build(self: ViteBundler, entry_file: Optional[Path] = None) ->
                 shutil.copy2(configs_package_json, build_package_json);
             }
             try {
-                # Install to .jac/client/node_modules
-                subprocess.run(
-                    ['npm', 'install'],
+                # Install to .jac/client/node_modules with progress feedback
+                print(
+                    "  ⏳ Installing npm dependencies (this may take a minute)...",
+                    flush=True
+                );
+                start_time = time.time();
+                result = subprocess.run(
+                    ['npm', 'install', '--progress'],
                     cwd=build_dir,
-                    check=True,
+                    check=False,
                     capture_output=True,
                     text=True
                 );
-            } except subprocess.CalledProcessError as e {
-                raise e from ClientBundleError(
-                    f"Failed to install npm dependencies: {e.stderr}"
-                ) ;
+                elapsed = time.time() - start_time;
+                if result.returncode != 0 {
+                    print(
+                        f"\n  ✖ npm install failed after {elapsed:.1f}s",
+                        file=sys.stderr
+                    );
+                    raise ClientBundleError(
+                        f"Failed to install npm dependencies: {result.stderr
+                        or result.stdout}"
+                    ) ;
+                }
+                print(f"  ✔ Dependencies installed ({elapsed:.1f}s)", flush=True);
             } except FileNotFoundError {
                 raise None from ClientBundleError(
                     'npm command not found. Ensure Node.js and npm are installed.'
@@ -431,15 +448,20 @@ impl ViteBundler.build(self: ViteBundler, entry_file: Optional[Path] = None) ->
             command = ['npm', 'run', 'build'];
         }
         # Run vite from client build directory so it can find node_modules
+        print("  ⏳ Building client bundle...", flush=True);
+        start_time = time.time();
         result = subprocess.run(
             command, cwd=build_dir, check=False, capture_output=True, text=True
         );
+        elapsed = time.time() - start_time;
         if result.returncode != 0 {
+            print(f"\n  ✖ Vite build failed after {elapsed:.1f}s", file=sys.stderr);
             error_msg = result.stderr or result.stdout or 'Unknown error';
             raise ClientBundleError(
                 f"Vite build failed:\n{error_msg}\nCommand: {' '.join(command)}"
             ) from None ;
         }
+        print(f"  ✔ Client bundle built ({elapsed:.1f}s)", flush=True);
     } finally {
         # Clean up temporary package.json in client build dir
         build_package_json = build_dir / 'package.json';
@@ -558,8 +580,54 @@ export default defineConfig({{
     return config_path;
 }
 
+"""Create config files from jac.toml [plugins.client.configs].
+
+Generates JavaScript config files (e.g., postcss.config.js, tailwind.config.js)
+from TOML configuration. Each key in [plugins.client.configs] becomes a config file.
+
+Example jac.toml:
+    [plugins.client.configs.postcss]
+    plugins = ["tailwindcss", "autoprefixer"]
+
+    [plugins.client.configs.tailwind]
+    content = ["./src/**/*.{js,jsx}"]
+
+This generates:
+    - .jac/client/configs/postcss.config.js
+    - .jac/client/configs/tailwind.config.js
+"""
+impl ViteBundler.create_config_files(self: ViteBundler) -> list[Path] {
+    configs = self.config_loader.get_configs();
+    if not configs {
+        return [];
+    }
+    build_dir = self._get_client_dir();
+    configs_dir = build_dir / 'configs';
+    configs_dir.mkdir(parents=True, exist_ok=True);
+    created_files: list[Path] = [];
+    for (config_name, config_data) in configs.items() {
+        config_path = configs_dir / f'{config_name}.config.js';
+
+        # Convert the TOML config to JavaScript module.exports
+        js_content = _toml_config_to_js(config_name, config_data);
+        config_path.write_text(js_content, encoding='utf-8');
+        created_files.append(config_path);
+    }
+    return created_files;
+}
+
+"""Convert TOML config data to JavaScript config file content.
+
+Generates a generic module.exports with the config data as JSON.
+"""
+def _toml_config_to_js(config_name: str, config_data: dict) -> str {
+    return f"module.exports = {json.dumps(config_data, indent=2)};\n";
+}
+
 """Start Vite dev server as a subprocess."""
 impl ViteBundler.start_dev_server(self: ViteBundler, port: int = 3000) -> Any {
+    import sys;
+    import time;
     build_dir = self._get_client_dir();
     node_modules = build_dir / 'node_modules';
     # Create/update index.html for dev server (load from compiled/ for HMR)
@@ -590,17 +658,30 @@ impl ViteBundler.start_dev_server(self: ViteBundler, port: int = 3000) -> Any {
             shutil.copy2(generated_package_json, build_package_json);
         }
         try {
-            print("[Vite] Installing dependencies...");
-            subprocess.run(
-                ['npm', 'install'],
+            print(
+                "  ⏳ Installing npm dependencies (this may take a minute)...",
+                flush=True
+            );
+            start_time = time.time();
+            result = subprocess.run(
+                ['npm', 'install', '--progress'],
                 cwd=build_dir,
-                check=True,
+                check=False,
                 capture_output=True,
                 text=True
             );
-        } except subprocess.CalledProcessError as e {
-            print(f"[Vite] Error installing dependencies: {e.stderr}");
-            raise ;
+            elapsed = time.time() - start_time;
+            if result.returncode != 0 {
+                print(
+                    f"\n  ✖ npm install failed after {elapsed:.1f}s", file=sys.stderr
+                );
+                print(f"  Error: {result.stderr or result.stdout}", file=sys.stderr);
+                raise ClientBundleError(
+                    f"Failed to install npm dependencies: {result.stderr
+                    or result.stdout}"
+                ) ;
+            }
+            print(f"  ✔ Dependencies installed ({elapsed:.1f}s)", flush=True);
         } finally {
             # Clean up temp package.json
             if build_package_json.exists() {
@@ -616,7 +697,7 @@ impl ViteBundler.start_dev_server(self: ViteBundler, port: int = 3000) -> Any {
         ) ;
     }
     config_rel = dev_config.relative_to(build_dir);
-    print(f"[Vite] Starting dev server on port {port}...");
+    logger.debug(f"Starting Vite dev server on port {port}");
     # Start Vite in dev mode (let output go to terminal for HMR visibility)
     process = subprocess.Popen(
         ['npx', 'vite', '--config', str(config_rel), '--port', str(port)],

jac_client/plugin/src/vite_bundler.jac

@@ -1,12 +1,15 @@
 """Vite bundling module."""
 import hashlib;
 import json;
+import logging;
 import shutil;
 import subprocess;
 import from pathlib { Path }
 import from typing { Any, Optional }
 import from jaclang.runtimelib.client_bundle { ClientBundleError }
 import from .config_loader { JacClientConfig }
+
+glob logger = logging.getLogger(__name__);
 """Handles Vite bundling operations."""
 class ViteBundler {
     def init(
@@ -34,6 +37,9 @@ class ViteBundler {
     ) -> Path;
 
     def create_tsconfig(self: ViteBundler) -> Path;
+    """Create config files from jac.toml [plugins.client.configs]."""
+    def create_config_files(self: ViteBundler) -> list[Path];
+
     """Create a dev-mode vite config with API proxy for HMR."""
     def create_dev_vite_config(
         self: ViteBundler, entry_file: Path, api_port: int = 8000

jac_client/plugin/utils/__init__.jac

@@ -0,0 +1 @@
+"""Utility modules for jac-client plugin."""