jac-client 0.2.8__py3-none-any.whl → 0.2.10__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/desktop_config.jac

@@ -0,0 +1,31 @@
+"""Configuration loader for Desktop target (Tauri).
+
+This module provides configuration access for the desktop target.
+Configuration is loaded from jac.toml under [desktop] section.
+
+Similar to JacClientConfig but loads [desktop] directly (not under [plugins]).
+"""
+import from pathlib { Path }
+import from typing { Any }
+import from jaclang.project.config { JacConfig, get_config }
+
+"""Desktop target configuration loader.
+
+Provides access to desktop/Tauri configuration
+from the [desktop] section of jac.toml.
+"""
+class DesktopConfig {
+    has project_dir: Path | None = None,
+        _config: dict[str, Any] | None = None,
+        _jac_config: JacConfig | None = None;
+
+    def init(self: DesktopConfig, project_dir: Path | None = None) -> None;
+    def load(self: DesktopConfig) -> dict[str, Any];
+    def get_desktop_config(self: DesktopConfig) -> dict[str, Any];
+    def get_window_config(self: DesktopConfig) -> dict[str, Any];
+    def get_platforms_config(self: DesktopConfig) -> dict[str, Any];
+    def get_features_config(self: DesktopConfig) -> dict[str, Any];
+    def validate(self: DesktopConfig) -> None;
+    def get_default_config(self: DesktopConfig) -> dict[str, Any];
+    # def _get_jac_config(self: DesktopConfig) -> JacConfig;
+}

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/desktop_config.impl.jac

@@ -0,0 +1,191 @@
+"""Implementation of Desktop target configuration loader."""
+import from pathlib { Path }
+import from typing { Any }
+import from jaclang.project.config { JacConfig, get_config }
+import from jaclang.project.plugin_config { deep_merge }
+import from jaclang.cli.console { console }
+
+"""Initialize DesktopConfig with project directory."""
+impl DesktopConfig.init(self: DesktopConfig, project_dir: Path | None = None) -> None {
+    if project_dir is None {
+        self.project_dir = Path.cwd();
+    } else {
+        self.project_dir = project_dir;
+    }
+    self._config = None;
+    self._jac_config = None;
+}
+
+"""Get default configuration structure for desktop target."""
+impl DesktopConfig.get_default_config(self: DesktopConfig) -> dict[str, Any] {
+    # Try to get project name/version from JacConfig for defaults
+    # If config is not available, use fallback defaults
+    project_name = "my-jac-app";
+    project_version = "1.0.0";
+    try {
+        jac_config = self._get_jac_config();
+        if jac_config and jac_config.project {
+            project_name = jac_config.project.name or project_name;
+            project_version = jac_config.project.version or project_version;
+        }
+    } except Exception {
+        # If config loading fails, use defaults
+        console.warning("Failed to load JacConfig, using fallback defaults");
+    }
+    # Generate identifier from project name
+    identifier = _generate_identifier(project_name);
+    return {
+        'name': project_name,
+        'identifier': identifier,
+        'version': project_version,
+        'window': {
+            'title': project_name,
+            'width': 1200,
+            'height': 800,
+            'min_width': 800,
+            'min_height': 600,
+            'resizable': True,
+            'fullscreen': False
+        },
+        'platforms': {'windows': True, 'macos': True, 'linux': True},
+        'features': {
+            'system_tray': False,
+            'auto_update': False,
+            'notifications': False
+        }
+    };
+}
+
+"""Get or load the core JacConfig instance."""
+impl DesktopConfig._get_jac_config(self: DesktopConfig) -> JacConfig {
+    if self._jac_config is None {
+        self._jac_config = get_config();
+        if self._jac_config is None {
+            raise RuntimeError(
+                "No jac.toml found. Run 'jac create' to create a project."
+            ) ;
+        }
+    }
+    return self._jac_config;
+}
+
+"""Load configuration from jac.toml, merging with defaults."""
+impl DesktopConfig.load(self: DesktopConfig) -> dict[str, Any] {
+    if self._config is not None {
+        return self._config;
+    }
+    default_config = self.get_default_config();
+    # Try to get [desktop] section from jac.toml
+    desktop_config = {};
+    try {
+        jac_config = self._get_jac_config();
+        # Get [desktop] section from raw TOML data
+        # The [desktop] section is not under [plugins], so we access it directly
+        if jac_config and jac_config._raw_data {
+            raw_data = jac_config._raw_data;
+            desktop_config = raw_data.get('desktop', {});
+        }
+    } except Exception {
+        # If config loading fails, use defaults only
+        console.warning("Failed to load JacConfig, using fallback defaults");
+    }
+    # Deep merge defaults with user configuration
+    if desktop_config {
+        self._config = deep_merge(default_config, desktop_config);
+    } else {
+        self._config = default_config;
+    }
+    return self._config;
+}
+
+"""Get desktop configuration (name, identifier, version)."""
+impl DesktopConfig.get_desktop_config(self: DesktopConfig) -> dict[str, Any] {
+    config = self.load();
+    return {
+        'name': config.get('name', ''),
+        'identifier': config.get('identifier', ''),
+        'version': config.get('version', '1.0.0')
+    };
+}
+
+"""Get window configuration."""
+impl DesktopConfig.get_window_config(self: DesktopConfig) -> dict[str, Any] {
+    config = self.load();
+    return config.get('window', {});
+}
+
+"""Get platforms configuration."""
+impl DesktopConfig.get_platforms_config(self: DesktopConfig) -> dict[str, Any] {
+    config = self.load();
+    return config.get('platforms', {});
+}
+
+"""Get features configuration."""
+impl DesktopConfig.get_features_config(self: DesktopConfig) -> dict[str, Any] {
+    config = self.load();
+    return config.get('features', {});
+}
+
+"""Validate desktop configuration."""
+impl DesktopConfig.validate(self: DesktopConfig) -> None {
+    config = self.load();
+    # Required fields
+    name = config.get('name', '');
+    if not name {
+        raise ValueError(
+            "Desktop configuration error: 'name' is required in [desktop] section"
+        ) ;
+    }
+    identifier = config.get('identifier', '');
+    if not identifier {
+        raise ValueError(
+            "Desktop configuration error: 'identifier' is required in [desktop] section"
+        ) ;
+    }
+    # Validate identifier format (should be reverse domain notation)
+    if not _is_valid_identifier(identifier) {
+        console.warning(
+            f"Desktop identifier '{identifier}' may not be valid. Use reverse domain notation (e.g., 'com.example.myapp')"
+        );
+    }
+    # Validate window dimensions
+    window = config.get('window', {});
+    width = window.get('width', 1200);
+    height = window.get('height', 800);
+    min_width = window.get('min_width', 800);
+    min_height = window.get('min_height', 600);
+    if min_width > width {
+        raise ValueError(
+            f"Desktop configuration error: window.min_width ({min_width}) cannot be greater than window.width ({width})"
+        ) ;
+    }
+    if min_height > height {
+        raise ValueError(
+            f"Desktop configuration error: window.min_height ({min_height}) cannot be greater than window.height ({height})"
+        ) ;
+    }
+}
+
+"""Generate identifier from project name."""
+def _generate_identifier(name: str) -> str {
+    # Convert to lowercase, replace spaces/special chars with dots
+    import re;
+    # Remove special characters, keep alphanumeric, dots, hyphens
+    cleaned = re.sub(r'[^a-zA-Z0-9.\-]', '', name.lower());
+    # Replace multiple dots/hyphens with single dot
+    cleaned = re.sub(r'[.\-]+', '.', cleaned);
+    # Remove leading/trailing dots
+    cleaned = cleaned.strip('.');
+    # If empty or doesn't look like reverse domain, prefix with 'com.'
+    if not cleaned or not '.' in cleaned {
+        cleaned = f"com.{cleaned}" if cleaned else "com.myapp";
+    }
+    return cleaned;
+}
+
+"""Check if identifier is valid (reverse domain notation)."""
+def _is_valid_identifier(identifier: str) -> bool {
+    import re;
+    # Should be like: com.example.myapp (at least one dot, alphanumeric + dots)
+    return bool(re.match(r'^[a-z0-9]+(\.[a-z0-9]+)+$', identifier.lower()));
+}