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

jac_client/plugin/cli.jac

@@ -9,10 +9,89 @@ For creating client projects, use: `jac create --use client`
 """
 
 import from jaclang.cli.registry { get_registry }
-import from jaclang.cli.command { Arg, HookContext }
+import from jaclang.cli.command { Arg, ArgKind, HookContext }
 import from jaclang.pycore.runtime { hookimpl }
 import os;
 
+glob registry = get_registry();
+
+# Register targets when module loads
+# Import base target classes - this should trigger annex pass to auto-discover .impl.jac files
+import from jac_client.plugin.src.targets.desktop_target {
+    DesktopTarget
+}
+import from jac_client.plugin.src.targets.web_target { WebTarget }
+import from jac_client.plugin.src.targets.register { register_targets }
+
+with entry {
+    register_targets();
+}
+
+"""Register 'build' command at module level."""
+@registry.command(
+    name="build",
+    help="Build a Jac application for a specific target",
+    args=[
+        Arg.create(
+            "filename",
+            kind=ArgKind.POSITIONAL,
+            default="main.jac",
+            help="Path to .jac file (default: main.jac)"
+        ),
+        Arg.create(
+            "client",
+            typ=str,
+            default="web",
+            help="Build client (web, desktop)",
+            choices=["web", "desktop"],
+            short=""  # Disable auto-generated -t (may conflict with other plugins)
+        ),
+        Arg.create(
+            "platform",
+            typ=str,
+            default=None,
+            help="Platform for desktop builds (windows, macos, linux, all)",
+            choices=["windows", "macos", "linux", "all"],
+            short="p"  # Use -p for platform
+        ),
+
+    ],
+    examples=[
+        ("jac build", "Build web target (default)"),
+        ("jac build main.jac", "Build specific file"),
+        ("jac build --client desktop", "Build desktop app"),
+        ("jac build --client desktop --platform windows", "Build for Windows"),
+
+    ],
+    group="build",
+    source="jac-client"
+)
+def build(
+    filename: str = "main.jac", target: str = "web", platform: str | None = None
+) -> int {
+    # This will be handled by the pre_hook
+    return 0;
+}
+
+"""Register 'setup' command at module level."""
+@registry.command(
+    name="setup",
+    help="Setup a build target (one-time initialization)",
+    args=[
+        Arg.create(
+            "target", kind=ArgKind.POSITIONAL, help="Target to setup (e.g., desktop)"
+        ),
+
+    ],
+    examples=[("jac setup desktop", "Setup desktop target (Tauri)"), ],
+    group="project",
+    source="jac-client"
+)
+def setup(target: str) -> int {
+    # This will be handled by the pre_hook
+    return 0;
+}
+
 """Jac CLI extensions for client-side development."""
 class JacCmd {
     """Create Jac CLI cmds."""
@@ -68,6 +147,37 @@ class JacCmd {
             pre_hook=_handle_npm_remove,
             source="jac-client"
         );
+
+        # Add pre-hook to build command (command is registered at module level)
+        registry.extend_command(
+            command_name="build", pre_hook=_handle_build_target, source="jac-client"
+        );
+
+        # Add pre-hook to setup command (command is registered at module level)
+        registry.extend_command(
+            command_name="setup", pre_hook=_handle_setup_target, source="jac-client"
+        );
+
+        # Extend 'start' command with --client flag
+        # Note: jac-scale also uses --client, so we use --client to avoid conflict
+        if registry.has_command("start") {
+            registry.extend_command(
+                command_name="start",
+                args=[
+                    Arg.create(
+                        "client",  # Use client to avoid conflict with jac-scale's --client
+                        typ=str,
+                        default="web",
+                        help="Client build target for dev server (web, desktop)",
+                        choices=["web", "desktop"],
+                        short=""  # Disable auto-generated short flag
+                    ),
+
+                ],
+                pre_hook=_handle_start_target,
+                source="jac-client"
+            );
+        }
     }
 }
 
@@ -174,6 +284,249 @@ def _handle_npm_add(ctx: HookContext) -> None {
     }
 }
 
+"""Pre-hook to handle --client flag for build command."""
+def _handle_build_target(ctx: HookContext) -> None {
+    import from jaclang.cli.console { console }
+    import from jac_client.plugin.src.targets.registry { get_target_registry }
+    import from pathlib { Path }
+    import from jaclang.project.config { get_config }
+
+    target_name = ctx.get_arg("client", "web");
+    platform = ctx.get_arg("platform", None);
+
+    registry = get_target_registry();
+    target = registry.get(target_name);
+
+    if not target {
+        console.error(f"Unknown client  target: {target_name}");
+        console.print(
+            f"Available client targets: {', '.join(
+                [t.name for t in registry.get_all()]
+            )}",
+            style="muted"
+        );
+        ctx.set_data("cancel_execution", True);
+        ctx.set_data("cancel_return_code", 1);
+        return;
+    }
+
+    # Store target info in context for use by build handler
+    ctx.set_data("build_target", target);
+    ctx.set_data("build_platform", platform);
+
+    # If target requires setup, warn user
+    if target.requires_setup {
+        console.warning(
+            f"Client target '{target_name}' requires setup. Run 'jac setup {target_name}' first."
+        );
+    }
+
+    # Build using target's build method
+    try {
+        config = get_config();
+        if not config {
+            console.error("No jac.toml found. Run 'jac create' to create a project.");
+            ctx.set_data("cancel_execution", True);
+            ctx.set_data("cancel_return_code", 1);
+            return;
+        }
+
+        entry_file = ctx.get_arg("filename", None);
+        if not entry_file {
+            entry_file = config.entry_point;
+        }
+        if not entry_file {
+            console.error("No entry file specified. Use: jac build <file>");
+            ctx.set_data("cancel_execution", True);
+            ctx.set_data("cancel_return_code", 1);
+            return;
+        }
+
+        entry_path = Path(entry_file);
+        project_dir = config.project_root or Path.cwd();
+        if not entry_path.is_absolute() {
+            entry_path = project_dir / entry_path;
+        }
+        bundle_path = target.build(entry_path, project_dir, platform);
+
+        console.success(f"Build complete: {bundle_path}");
+        ctx.set_data("cancel_execution", True);
+        ctx.set_data("cancel_return_code", 0);
+    } except NotImplementedError as e {
+        console.error(
+            f"Target '{target_name}' is not yet implemented. Coming in Phase 2!"
+        );
+        ctx.set_data("cancel_execution", True);
+        ctx.set_data("cancel_return_code", 1);
+    } except Exception as e {
+        console.error(f"Build failed: {e}");
+        ctx.set_data("cancel_execution", True);
+        ctx.set_data("cancel_return_code", 1);
+    }
+}
+
+"""Pre-hook to handle --client flag for start command."""
+def _handle_start_target(ctx: HookContext) -> None {
+    import from jaclang.cli.console { console }
+    import from jac_client.plugin.src.targets.registry { get_target_registry }
+
+    target_name = ctx.get_arg("client", "web");
+
+    registry = get_target_registry();
+    target = registry.get(target_name);
+
+    if not target {
+        console.error(f"Unknown client target:  {target_name}");
+        console.print(
+            f"Available client targets: {', '.join(
+                [t.name for t in registry.get_all()]
+            )}",
+            style="muted"
+        );
+        ctx.set_data("cancel_execution", True);
+        ctx.set_data("cancel_return_code", 1);
+        return;
+    }
+
+    # Store target info in context
+    ctx.set_data("start_client_target", target);
+
+    # Handle desktop target
+    if target_name == "desktop" {
+        import from pathlib { Path }
+        import from jaclang.project.config { get_config }
+        config = get_config();
+        if not config {
+            console.error("No jac.toml found. Run 'jac create' to create a project.");
+            ctx.set_data("cancel_execution", True);
+            ctx.set_data("cancel_return_code", 1);
+            return;
+        }
+        # Get entry file
+        entry_file = ctx.get_arg("filename", None);
+        if not entry_file {
+            entry_file = config.entry_point;
+        }
+        if not entry_file {
+            console.error("No entry file specified. Use: jac start <file>");
+            ctx.set_data("cancel_execution", True);
+            ctx.set_data("cancel_return_code", 1);
+            return;
+        }
+        entry_path = Path(entry_file);
+        project_dir = config.project_root or Path.cwd();
+        if not entry_path.is_absolute() {
+            entry_path = project_dir / entry_path;
+        }
+        # Check if setup has been run
+        tauri_dir = project_dir / "src-tauri";
+        if not tauri_dir.exists() {
+            console.error("Desktop target not set up. Run 'jac setup desktop' first.");
+            ctx.set_data("cancel_execution", True);
+            ctx.set_data("cancel_return_code", 1);
+            return;
+        }
+        # Check if --dev flag is set
+        dev_mode = ctx.get_arg("dev", False);
+        try {
+            if dev_mode {
+                # Desktop target with --dev: launch Tauri dev mode (hot reload)
+                target.dev(entry_path, project_dir);
+            } else {
+                # Desktop target without --dev: build web bundle and launch Tauri with built bundle
+                target.start(entry_path, project_dir);
+            }
+            ctx.set_data("cancel_execution", True);
+            ctx.set_data("cancel_return_code", 0);
+        } except Exception as e {
+            import traceback;
+            console.error(f"Desktop start failed: {e}");
+            console.print(traceback.format_exc(), style="muted");
+            ctx.set_data("cancel_execution", True);
+            ctx.set_data("cancel_return_code", 1);
+        }
+        return;
+    }
+    # Web target: let existing start command handle it
+    # (no cancellation, let it run normally)
+}
+
+"""Pre-hook to handle setup command."""
+def _handle_setup_target(ctx: HookContext) -> None {
+    import from jaclang.cli.console { console }
+    import from jac_client.plugin.src.targets.registry { get_target_registry }
+    import from pathlib { Path }
+    import from jaclang.project.config { get_config }
+
+    target_name = ctx.get_arg("target", None);
+    if not target_name {
+        console.error("No target specified. Use: jac setup <target>");
+        console.print("Available targets: desktop", style="muted");
+        ctx.set_data("cancel_execution", True);
+        ctx.set_data("cancel_return_code", 1);
+        return;
+    }
+
+    registry = get_target_registry();
+    target = registry.get(target_name);
+
+    if not target {
+        console.error(f"Unknown client target: {target_name}");
+        console.print(
+            f"Available targets: {', '.join([t.name for t in registry.get_all()])}",
+            style="muted"
+        );
+        ctx.set_data("cancel_execution", True);
+        ctx.set_data("cancel_return_code", 1);
+        return;
+    }
+
+    # Setup using target's setup method
+    try {
+        config = get_config();
+        if not config {
+            console.error("No jac.toml found. Run 'jac create' to create a project.");
+            ctx.set_data("cancel_execution", True);
+            ctx.set_data("cancel_return_code", 1);
+            return;
+        }
+
+        project_dir = config.project_root or Path.cwd();
+        console.print(
+            f"Setting up target '{target_name}' in: {project_dir}", style="muted"
+        );
+        target.setup(project_dir);
+
+        # Verify setup completed successfully
+        tauri_dir = project_dir / "src-tauri";
+        if not tauri_dir.exists() {
+            console.error(
+                f"Setup completed but src-tauri directory not found at: {tauri_dir}"
+            );
+            console.print(
+                "This may indicate the setup function failed silently.", style="muted"
+            );
+            ctx.set_data("cancel_execution", True);
+            ctx.set_data("cancel_return_code", 1);
+            return;
+        }
+
+        console.success(f"Target '{target_name}' setup complete!");
+        ctx.set_data("cancel_execution", True);
+        ctx.set_data("cancel_return_code", 0);
+    } except NotImplementedError as e {
+        console.error(f"Target '{target_name}' setup is not yet implemented.");
+        ctx.set_data("cancel_execution", True);
+        ctx.set_data("cancel_return_code", 1);
+    } except Exception as e {
+        import traceback;
+        console.error(f"Setup failed: {e}");
+        console.print(traceback.format_exc(), style="muted");
+        ctx.set_data("cancel_execution", True);
+        ctx.set_data("cancel_return_code", 1);
+    }
+}
+
 """Pre-hook to handle --npm flag for removing npm dependencies."""
 def _handle_npm_remove(ctx: HookContext) -> None {
     # Check if --npm flag is set

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/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()));
+}