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

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

@@ -7,9 +7,7 @@ impl ViteBundler._get_client_dir(self: ViteBundler) -> Path {
         if config is not None {
             return config.get_client_dir();
         }
-    } except ImportError {
-        pass;
-    }
+    } except ImportError { }
     # Fallback to default
     return self.project_dir / '.jac' / 'client';
 }
@@ -80,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;
 }
 
@@ -377,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() {
@@ -397,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.'
@@ -433,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';
@@ -475,3 +495,213 @@ impl ViteBundler.init(
     # Set output_dir after config_loader is initialized so _get_client_dir works
     self.output_dir = output_dir or (self._get_client_dir() / 'dist');
 }
+
+"""Create a dev-mode vite config with API proxy for HMR."""
+impl ViteBundler.create_dev_vite_config(
+    self: ViteBundler, entry_file: Path, api_port: int = 8000
+) -> Path {
+    build_dir = self._get_client_dir();
+    build_dir.mkdir(parents=True, exist_ok=True);
+    configs_dir = build_dir / 'configs';
+    configs_dir.mkdir(exist_ok=True);
+    config_path = configs_dir / 'vite.dev.config.js';
+    # Get entry file relative path
+    try {
+        entry_relative = entry_file.relative_to(build_dir).as_posix();
+    } except ValueError {
+        entry_relative = entry_file.as_posix();
+    }
+    # Calculate paths for aliases
+    if entry_relative.endswith('/build/main.js') {
+        compiled_utils_relative = entry_relative[:-13] + '/compiled/client_runtime.js';
+        compiled_assets_relative = entry_relative[:-13] + '/compiled/assets';
+    } elif entry_relative.endswith('build/main.js') {
+        compiled_utils_relative = 'compiled/client_runtime.js';
+        compiled_assets_relative = 'compiled/assets';
+    } else {
+        compiled_utils_relative = 'compiled/client_runtime.js';
+        compiled_assets_relative = 'compiled/assets';
+    }
+    # Extensions for TypeScript
+    extensions = ['.mjs', '.js', '.mts', '.ts', '.jsx', '.tsx', '.json'];
+    extensions_str = ', '.join(f'"{ext}"' for ext in extensions);
+    # Generate dev config with proxy for API routes
+    config_content = f'''import {{ defineConfig }} from "vite";
+import path from "path";
+import {{ fileURLToPath }} from "url";
+import react from "@vitejs/plugin-react";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const buildDir = path.resolve(__dirname, "..");
+const projectRoot = path.resolve(__dirname, "../../..");
+
+/**
+ * Vite DEV configuration for HMR mode
+ * Proxies API routes to Python server at localhost:{api_port}
+ */
+export default defineConfig({{
+  plugins: [react()],
+  root: buildDir,
+  publicDir: false,
+  server: {{
+    watch: {{
+      usePolling: true,
+      interval: 100,
+    }},
+    proxy: {{
+      "/walker": {{
+        target: "http://localhost:{api_port}",
+        changeOrigin: true,
+      }},
+      "/function": {{
+        target: "http://localhost:{api_port}",
+        changeOrigin: true,
+      }},
+      "/user": {{
+        target: "http://localhost:{api_port}",
+        changeOrigin: true,
+      }},
+      "/introspect": {{
+        target: "http://localhost:{api_port}",
+        changeOrigin: true,
+      }},
+    }},
+  }},
+  resolve: {{
+    alias: {{
+      "@jac-client/utils": path.resolve(buildDir, "{compiled_utils_relative}"),
+      "@jac-client/assets": path.resolve(buildDir, "{compiled_assets_relative}"),
+    }},
+    extensions: [{extensions_str}],
+  }},
+}});
+''';
+    config_path.write_text(config_content, encoding='utf-8');
+    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)
+    index_html = build_dir / 'index.html';
+    index_content = '''<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Jac App (Dev)</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/compiled/_entry.js"></script>
+  </body>
+</html>
+''';
+    index_html.write_text(index_content, encoding='utf-8');
+    # Ensure dependencies are installed
+    if not node_modules.exists() {
+        generated_package_json = build_dir / 'configs' / 'package.json';
+        if not generated_package_json.exists() {
+            self.create_package_json();
+        }
+        # Temporarily copy package.json for npm install
+        build_package_json = build_dir / 'package.json';
+        if not build_package_json.exists() {
+            shutil.copy2(generated_package_json, build_package_json);
+        }
+        try {
+            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=False,
+                capture_output=True,
+                text=True
+            );
+            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() {
+                build_package_json.unlink();
+            }
+        }
+    }
+    # Find the dev config
+    dev_config = build_dir / 'configs' / 'vite.dev.config.js';
+    if not dev_config.exists() {
+        raise ClientBundleError(
+            "Dev config not found. Call create_dev_vite_config first."
+        ) ;
+    }
+    config_rel = dev_config.relative_to(build_dir);
+    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)],
+        cwd=build_dir
+    );
+    return process;
+}

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 { Optional }
+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,4 +37,14 @@ 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
+    ) -> Path;
+
+    """Start Vite dev server as a subprocess."""
+    def start_dev_server(self: ViteBundler, port: int = 3000) -> Any;
 }

jac_client/plugin/utils/__init__.jac

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

jac_client/plugin/utils/impl/node_installer.impl.jac

@@ -0,0 +1,249 @@
+"""Implementation of Node.js installer methods."""
+
+"""Check if Node.js is installed and accessible."""
+impl NodeInstaller.is_node_installed -> bool {
+    try {
+        result = subprocess.run(
+            ['node', '--version'], capture_output=True, text=True, timeout=5
+        );
+        return result.returncode == 0;
+    } except (FileNotFoundError, subprocess.TimeoutExpired) {
+        return False;
+    }
+}
+
+"""Check if npm is installed and accessible."""
+impl NodeInstaller.is_npm_installed -> bool {
+    try {
+        result = subprocess.run(
+            ['npm', '--version'], capture_output=True, text=True, timeout=5
+        );
+        return result.returncode == 0;
+    } except (FileNotFoundError, subprocess.TimeoutExpired) {
+        return False;
+    }
+}
+
+"""Check if NVM is installed."""
+impl NodeInstaller.is_nvm_installed -> bool {
+    nvm_dir = Path.home() / '.nvm';
+    return nvm_dir.exists() and (nvm_dir / 'nvm.sh').exists();
+}
+
+"""Get the currently installed Node.js version."""
+impl NodeInstaller.get_node_version -> (str | None) {
+    try {
+        result = subprocess.run(
+            ['node', '--version'], capture_output=True, text=True, timeout=5
+        );
+        if result.returncode == 0 {
+            return result.stdout.strip();
+        }
+    } except (FileNotFoundError, subprocess.TimeoutExpired) { }
+    return None;
+}
+
+"""Install NVM (Node Version Manager)."""
+impl NodeInstaller.install_nvm -> tuple[bool, str] {
+    system = platform.system();
+    if system == 'Windows' {
+        return (
+            False,
+            'Windows detected. Please install Node.js manually:\n' + '  1. Download from: https://nodejs.org/\n' + '  2. Or use nvm-windows: https://github.com/coreybutler/nvm-windows\n' + '  After installation, run "jac add --cl" again.'
+        );
+    }
+    print('Installing NVM (Node Version Manager)...');
+    try {
+        # Download and run NVM installation script
+        install_script = subprocess.run(
+            ['curl', '-o-', NodeInstaller.NVM_INSTALL_URL],
+            capture_output=True,
+            text=True,
+            timeout=30
+        );
+
+        if install_script.returncode != 0 {
+            return (
+                False,
+                f'Failed to download NVM installer: {install_script.stderr}'
+            );
+        }
+
+        # Execute the installation script
+        result = subprocess.run(
+            ['bash', '-c', install_script.stdout],
+            capture_output=True,
+            text=True,
+            timeout=60
+        );
+
+        if result.returncode != 0 {
+            return (False, f'NVM installation failed: {result.stderr}');
+        }
+
+        print('NVM installed successfully!');
+        return (True, 'NVM installed successfully');
+    } except subprocess.TimeoutExpired {
+        return (
+            False,
+            'NVM installation timed out. Please check your internet connection.'
+        );
+    } except FileNotFoundError as e {
+        if 'curl' in str(e) {
+            return (
+                False,
+                'curl command not found. Please install curl first:\n' + '  Ubuntu/Debian: sudo apt-get install curl\n' + '  macOS: curl is pre-installed\n' + '  Fedora/RHEL: sudo dnf install curl'
+            );
+        }
+        return (False, f'Required command not found: {e}');
+    } except Exception as e {
+        return (False, f'Unexpected error during NVM installation: {e}');
+    }
+}
+
+"""Install Node.js using NVM."""
+impl NodeInstaller.install_node_via_nvm(version: str = "20") -> tuple[bool, str] {
+    print(f'Installing Node.js v{version} via NVM...');
+    nvm_dir = Path.home() / '.nvm';
+    nvm_script = nvm_dir / 'nvm.sh';
+    if not nvm_script.exists() {
+        return (False, 'NVM is not installed or nvm.sh not found');
+    }
+    try {
+        # Source NVM and install Node.js
+        command = (
+            'export NVM_DIR="$HOME/.nvm"\n' + '[ -s "$NVM_DIR/nvm.sh" ] && . "$NVM_DIR/nvm.sh"\n' + f'nvm install {version}\n' + f'nvm use {version}\n' + f'nvm alias default {version}\n'
+        );
+
+        result = subprocess.run(
+            ['bash', '-c', command], capture_output=True, text=True, timeout=300
+        );
+
+        if result.returncode != 0 {
+            return (False, f'Node.js installation failed: {result.stderr}');
+        }
+
+        print(f'Node.js v{version} installed successfully!');
+        return (True, f'Node.js v{version} installed successfully');
+    } except subprocess.TimeoutExpired {
+        return (False, 'Node.js installation timed out. Please try again.');
+    } except Exception as e {
+        return (False, f'Unexpected error during Node.js installation: {e}');
+    }
+}
+
+"""Ensure Node.js is installed, installing automatically if needed.
+
+Returns tuple of (success: bool, message: str, was_just_installed: bool)
+"""
+impl NodeInstaller.ensure_node_installed(
+    interactive: bool = True
+) -> tuple[bool, str, bool] {
+    # Common fallback message for manual installation
+    manual_install_msg = (
+        'Please install Node.js manually:\n' + '  • Download from: https://nodejs.org/\n' + '  • Or install NVM: https://github.com/nvm-sh/nvm\n' + '  After installation, run "jac add --cl" again.'
+    );
+    # Check if Node.js is already available
+    if NodeInstaller.is_node_installed() and NodeInstaller.is_npm_installed() {
+        version = NodeInstaller.get_node_version();
+        return (True, f'Node.js {version} is already installed', False);
+    }
+    print('\nNode.js is not installed or not found in PATH.');
+    # Check for interactive mode
+    if interactive {
+        print(
+            '\nJac client requires Node.js to build and run client-side applications.'
+        );
+        print(
+            f'Would you like to automatically install Node.js v{NodeInstaller.DEFAULT_NODE_VERSION} using NVM?'
+        );
+        response = input('Install Node.js? [Y/n]: ').strip().lower();
+        if response and response not in ('y', 'yes') {
+            return (
+                False,
+                f'Node.js installation cancelled. {manual_install_msg}',
+                False
+            );
+        }
+    }
+    # Wrap entire installation process in error handling
+    try {
+        # Check if NVM is installed
+        if not NodeInstaller.is_nvm_installed() {
+            success_nvm = NodeInstaller.install_nvm();
+            if not success_nvm[0] {
+                return (
+                    False,
+                    f'Unable to automatically install Node.js.\n\nError: {success_nvm[
+                        1
+                    ]}\n\n{manual_install_msg}',
+                    False
+                );
+            }
+        }
+
+        # Install Node.js via NVM
+        success_node = NodeInstaller.install_node_via_nvm();
+        if not success_node[0] {
+            return (
+                False,
+                f'Unable to automatically install Node.js.\n\nError: {success_node[1]}\n\n{manual_install_msg}',
+                False
+            );
+        }
+
+        # Node.js is now available via NVM sourcing in subprocesses
+        print('\n' + '=' * 70);
+        print('Node.js has been installed successfully!');
+        print('Continuing with package installation...');
+        print('=' * 70 + '\n');
+
+        return (
+            True,
+            f'Node.js {NodeInstaller.DEFAULT_NODE_VERSION} installed successfully',
+            True
+        );
+    } except Exception as e {
+        # Catch any unexpected errors during installation
+        return (
+            False,
+            f'Unable to automatically install Node.js.\n\nUnexpected error: {str(e)}\n\n{manual_install_msg}',
+            False
+        );
+    }
+}
+
+"""Run npm command with NVM environment properly sourced.
+
+This method automatically sources NVM in a subprocess, so npm commands work
+immediately after NVM installation without requiring the user to reload their shell.
+"""
+impl NodeInstaller.run_npm_with_nvm(
+    args: list, cwd: Path, timeout: int = 300
+) -> object {
+    # First, try running npm directly (in case it's already in PATH)
+    try {
+        return subprocess.run(
+            ['npm'] + args,
+            cwd=cwd,
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+            check=True
+        );
+    } except FileNotFoundError { }
+    # If npm is not in PATH, source NVM and run npm in a subprocess
+    # This allows npm to work immediately after installation without shell reload
+    args_str = ' '.join(args);
+    command = (
+        'export NVM_DIR="$HOME/.nvm"\n' + '[ -s "$NVM_DIR/nvm.sh" ] && . "$NVM_DIR/nvm.sh"\n' + f'npm {args_str}\n'
+    );
+    return subprocess.run(
+        ['bash', '-c', command],
+        cwd=cwd,
+        capture_output=True,
+        text=True,
+        timeout=timeout,
+        check=True
+    );
+}

jac_client/plugin/utils/node_installer.jac

@@ -0,0 +1,41 @@
+"""Automatic Node.js installation utility using NVM."""
+
+import os;
+import platform;
+import subprocess;
+import from pathlib { Path }
+
+"""Handles Node.js installation and detection."""
+obj NodeInstaller {
+    static has DEFAULT_NODE_VERSION: str = "20",
+        NVM_INSTALL_URL: str = "https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh";
+
+    """Check if Node.js is installed and accessible."""
+    static def is_node_installed -> bool;
+
+    """Check if npm is installed and accessible."""
+    static def is_npm_installed -> bool;
+
+    """Check if NVM is installed."""
+    static def is_nvm_installed -> bool;
+
+    """Get the currently installed Node.js version."""
+    static def get_node_version -> (str | None);
+
+    """Install NVM (Node Version Manager)."""
+    static def install_nvm -> tuple[bool, str];
+
+    """Install Node.js using NVM."""
+    static def install_node_via_nvm(version: str = "20") -> tuple[bool, str];
+
+    """Ensure Node.js is installed, installing automatically if needed.
+
+    Returns tuple of (success: bool, message: str, was_just_installed: bool)
+    """
+    static def ensure_node_installed(
+        interactive: bool = True
+    ) -> tuple[bool, str, bool];
+
+    """Run npm command with NVM environment properly sourced."""
+    static def run_npm_with_nvm(args: list, cwd: Path, timeout: int = 300) -> object;
+}