jac-client 0.2.6__py3-none-any.whl → 0.2.11__py3-none-any.whl

jac_client/plugin/cli.jac

@@ -1,547 +1,584 @@
 """Command line interface tool for the Jac Client.
 
-This module extends the core `create` command to add client-side (frontend)
-project setup via the --cl flag.
+This module extends core CLI commands to add the --npm flag for
+client-side (frontend) package management:
+- `jac add --npm`: Add npm dependencies
+- `jac remove --npm`: Remove npm dependencies
+
+For creating client projects, use: `jac create --use client`
 """
 
-import os;
-import re;
-import sys;
-import pathlib;
-import subprocess;
-import shutil;
-import from jaclang.cli.cmdreg { cmd_registry, CommandPriority }
+import from jaclang.cli.registry { get_registry }
+import from jaclang.cli.command { Arg, ArgKind, HookContext }
 import from jaclang.pycore.runtime { hookimpl }
-import from jaclang.project.config { JacConfig, find_project_root }
+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."""
     @hookimpl
     static def create_cmd -> None {
-        """Override core create command to add --cl flag for client-side setup.""";
-
-        def create(
-            name: str = 'main',
-            force: bool = False,
-            cl: bool = False,
-            skip: bool = False,
-            verbose: bool = False
-        ) -> None {
-            """Initialize a new Jac project.
-
-            Creates a jac.toml configuration file and basic project structure.
-            Use --cl to include client-side (frontend) setup with Vite bundling.
-
-            Args:
-                name: Project name (default: 'main')
-                force: Overwrite existing jac.toml if present
-                cl: Include client-side (frontend) setup
-                skip: Skip installing default packages (only for --cl projects)
-                verbose: Show detailed output during package installation
-
-            Examples:
-                jac create
-                jac create myapp
-                jac create --cl myapp
-                jac create --cl --skip myapp
-                jac create --cl --verbose myapp
-                jac create --force
-            """;
-            cwd = pathlib.Path(os.getcwd());
-
-            if cl {
-                _create_client_project(cwd, name, force, skip, verbose);
-            } else {
-                _create_core_project(cwd, name, force);
-            }
-        }
+        """Extend core commands to add --npm flag for npm package management.""";
+        registry = get_registry();
+
+        # Extend the core 'create' command with --skip flag for client template
+        registry.extend_command(
+            command_name="create",
+            args=[
+                Arg.create(
+                    "skip",
+                    typ=bool,
+                    default=False,
+                    help="Skip npm package installation (for --use client)"
+                ),
+
+            ],
+            pre_hook=_handle_create_skip,
+            source="jac-client"
+        );
 
-        # Register with PLUGIN priority to override core's create command
-        cmd_registry.register(
-            create, priority=CommandPriority.PLUGIN, source="jac-client"
+        # Extend the core 'add' command with --npm flag
+        registry.extend_command(
+            command_name="add",
+            args=[
+                Arg.create(
+                    "npm",
+                    typ=bool,
+                    default=False,
+                    help="Add as npm (client-side) dependency"
+                ),
+
+            ],
+            pre_hook=_handle_npm_add,
+            source="jac-client"
         );
-    }
-}
 
-"""Create a standard Jac project (core behavior)."""
-def _create_core_project(cwd: pathlib.Path, name: str, force: bool) -> None {
-    existing = find_project_root(cwd);
-    if existing and not force {
-        (project_root, toml_path) = existing;
-        print(f"Already in a Jac project: {toml_path}", file=sys.stderr);
-        print("Use --force to reinitialize.", file=sys.stderr);
-        <>exit(1);
-    }
+        # Extend the core 'remove' command with --npm flag
+        registry.extend_command(
+            command_name="remove",
+            args=[
+                Arg.create(
+                    "npm",
+                    typ=bool,
+                    default=False,
+                    help="Remove npm (client-side) dependency"
+                ),
+
+            ],
+            pre_hook=_handle_npm_remove,
+            source="jac-client"
+        );
 
-    project_name = name or cwd.name;
+        # 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"
+        );
 
-    toml_path = cwd / "jac.toml";
-    if toml_path.exists() and not force {
-        print("jac.toml already exists. Use --force to overwrite.", file=sys.stderr);
-        <>exit(1);
-    }
+        # 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"
+        );
 
-    toml_content = JacConfig.create_default_toml(project_name);
-    with open(toml_path, "w") as f {
-        f.write(toml_content);
-    }
-    print(f"Created {toml_path}");
-
-    main_jac = cwd / f"{name}.jac";
-    if not main_jac.exists() {
-        with open(main_jac, "w") as f {
-            f.write(
-                f'''"""Main entry point for {project_name}."""
-
-with entry {{
-    print("Hello from {project_name}!");
-}}
-'''
+        # 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"
             );
         }
-        print(f"Created {main_jac}");
     }
+}
 
-    packages_dir = cwd / "packages";
-    if not packages_dir.exists() {
-        packages_dir.mkdir(parents=True, exist_ok=True);
-        print(f"Created {packages_dir}/");
+"""Pre-hook to handle --skip flag for create command."""
+def _handle_create_skip(ctx: HookContext) -> None {
+    # Check if --skip flag is set
+    skip_flag = ctx.get_arg("skip", False);
+    if skip_flag {
+        # Set environment variable to skip npm installation
+        os.environ["JAC_CLIENT_SKIP_NPM_INSTALL"] = "1";
     }
+    # Let core create command run normally
+}
 
-    _create_gitignore(cwd, client=False);
+"""Pre-hook to handle --npm flag for adding npm dependencies."""
+def _handle_npm_add(ctx: HookContext) -> None {
+    # Check if --npm flag is set
+    npm_flag = ctx.get_arg("npm", False);
+    if not npm_flag {
+        # Let core add command run normally
+        return;
+    }
 
-    print(f"\nProject '{project_name}' initialized successfully!");
-    print("\nNext steps:");
-    print("  jac run main.jac    # Run the main entry point");
-    print("  jac add <package>   # Add dependencies");
-    print("  jac install         # Install all dependencies");
-}
+    import from jaclang.project.config { get_config }
+    import from jaclang.project.dep_registry { get_dependency_registry }
+    import from jaclang.project.dependencies { DependencyResolver }
+    import from jaclang.cli.console { console }
 
-"""Create a client-side Jac project with organized folder structure."""
-def _create_client_project(
-    cwd: pathlib.Path,
-    name: str,
-    force: bool,
-    skip: bool = False,
-    verbose: bool = False
-) -> None {
-    project_name = name or cwd.name;
-
-    if not project_name or project_name == 'main' {
-        print(
-            "Error: Project name is required for client projects. Use: jac create --cl <name>",
-            file=sys.stderr
+    config = get_config();
+    if config is None {
+        console.error(
+            "No jac.toml found", hint="Run 'jac create' to create a project."
         );
-        <>exit(1);
+        ctx.set_data("cancel_execution", True);
+        ctx.set_data("cancel_return_code", 1);
+        return;
     }
 
-    if not re.match('^[a-zA-Z0-9_-]+$', project_name) {
-        print(
-            "Error: Project name must contain only letters, numbers, hyphens, and underscores",
-            file=sys.stderr
+    registry = get_dependency_registry();
+    dep_type = registry.get_by_flag("--npm");
+    if dep_type is None {
+        console.error(
+            "--npm flag requires jac-client plugin",
+            hint="Install with: pip install jac-client"
         );
-        <>exit(1);
+        ctx.set_data("cancel_execution", True);
+        ctx.set_data("cancel_return_code", 1);
+        return;
     }
 
-    existing = find_project_root(cwd);
-    if existing and not force {
-        (project_root, toml_path) = existing;
-        print(f"Already in a Jac project: {toml_path}", file=sys.stderr);
-        print("Use --force to reinitialize.", file=sys.stderr);
-        <>exit(1);
-    }
+    packages = ctx.get_arg("packages", []);
+    dev = ctx.get_arg("dev", False);
 
-    project_path: pathlib.Path;
-    if name and name != cwd.name {
-        project_path = cwd / name;
-        if project_path.exists() and not force {
-            print(f"Error: Directory '{name}' already exists", file=sys.stderr);
-            <>exit(1);
+    # If no packages specified, install all npm packages from jac.toml
+    if not packages {
+        if dep_type.install_all_handler is None {
+            console.error(f"No install_all handler registered for {dep_type.name}");
+            ctx.set_data("cancel_execution", True);
+            ctx.set_data("cancel_return_code", 1);
+            return;
         }
-        project_path.mkdir(parents=True, exist_ok=True);
-    } else {
-        project_path = cwd;
+        try {
+            console.print(
+                f"\n📦 Installing all {dep_type.name} packages from jac.toml",
+                style="bold"
+            );
+            with console.status(
+                f"[cyan]Installing {dep_type.name} packages...[/cyan]", spinner="dots"
+            ) as status {
+                dep_type.install_all_handler(config);
+            }
+            console.success(f"Installed all {dep_type.name} packages");
+            ctx.set_data("cancel_execution", True);
+            ctx.set_data("cancel_return_code", 0);
+        } except Exception as e {
+            console.error(f"Failed to install packages: {e}");
+            ctx.set_data("cancel_execution", True);
+            ctx.set_data("cancel_return_code", 1);
+        }
+        return;
     }
 
-    print(f"Creating Jac client application: {project_name}");
-
-    src_dir = project_path / "src";
-    src_dir.mkdir(parents=True, exist_ok=True);
-
-    components_dir = src_dir / "components";
-    components_dir.mkdir(parents=True, exist_ok=True);
-
-    assets_dir = project_path / "assets";
-    assets_dir.mkdir(parents=True, exist_ok=True);
-
-    (project_path / ".client-build").mkdir(parents=True, exist_ok=True);
-
-    toml_path = project_path / "jac.toml";
-    toml_content = f'''[project]
-name = "{project_name}"
-version = "1.0.0"
-description = "Jac client application: {project_name}"
-entry-point = "src/app.jac"
-
-[plugins.client]
-# Vite bundler configuration (optional overrides)
-# vite.plugins = []
-# vite.build = {{}}
-''';
-    with open(toml_path, 'w') as f {
-        f.write(toml_content);
-    }
-    print(f"Created {toml_path}");
-
-    app_jac_content = '''"""Main entry point for the Jac client application."""
-
-# Client-side imports
-cl import from react { useState, useEffect }
-cl import from ".components/Button.tsx" { Button }
-
-# Client-side component
-cl {
-    def:pub app() -> any {
-        [count, setCount] = useState(0);
-
-        useEffect(lambda -> None {
-            console.log("Count updated:", count);
-        }, [count]);
-
-        return <div style={{padding: "2rem", fontFamily: "Arial, sans-serif"}}>
-            <h1>Hello, World!</h1>
-            <p>Count: {count}</p>
-            <div style={{display: "flex", gap: "1rem", marginTop: "1rem"}}>
-                <Button
-                    label="Increment"
-                    onClick={lambda -> None { setCount(count + 1); }}
-                    variant="primary"
-                />
-                <Button
-                    label="Reset"
-                    onClick={lambda -> None { setCount(0); }}
-                    variant="secondary"
-                />
-            </div>
-        </div>;
-    }
-}
-''';
-    with open(src_dir / "app.jac", 'w') as f {
-        f.write(app_jac_content);
+    # Install specific packages
+    try {
+        resolver = DependencyResolver(config=config);
+        console.print(
+            f"\n📦 Adding {len(packages)} {dep_type.name} package(s)", style="bold"
+        );
+        for pkg_spec in packages {
+            (name, version) = resolver.parse_spec(pkg_spec);
+            with console.status(f"[cyan]Installing {name}...[/cyan]", spinner="dots") as status {
+                dep_type.install_handler(config, name, version, dev);
+            }
+            console.print(f"  ✔ {name}", style="success");
+        }
+        section = f"dependencies.{dep_type.dev_name if dev else dep_type.name}";
+        console.print(f"\n  ✔ Updated jac.toml [{section}]", style="muted");
+        ctx.set_data("cancel_execution", True);
+        ctx.set_data("cancel_return_code", 0);
+    } except Exception as e {
+        console.error(f"Failed to install packages: {e}");
+        ctx.set_data("cancel_execution", True);
+        ctx.set_data("cancel_return_code", 1);
     }
-    print("Created src/app.jac");
-
-    button_tsx_content = '''import React from 'react';
-
-interface ButtonProps {
-  label: string;
-  onClick?: () => void;
-  variant?: 'primary' | 'secondary';
-  disabled?: boolean;
 }
 
-export const Button: React.FC<ButtonProps> = ({
-  label,
-  onClick,
-  variant = 'primary',
-  disabled = false
-}) => {
-  const baseStyles: React.CSSProperties = {
-    padding: '0.75rem 1.5rem',
-    fontSize: '1rem',
-    fontWeight: '600',
-    borderRadius: '0.5rem',
-    border: 'none',
-    cursor: disabled ? 'not-allowed' : 'pointer',
-    transition: 'all 0.2s ease',
-  };
-
-  const variantStyles: Record<string, React.CSSProperties> = {
-    primary: {
-      backgroundColor: disabled ? '#9ca3af' : '#3b82f6',
-      color: '#ffffff',
-    },
-    secondary: {
-      backgroundColor: disabled ? '#e5e7eb' : '#6b7280',
-      color: '#ffffff',
-    },
-  };
-
-  return (
-    <button
-      style={{ ...baseStyles, ...variantStyles[variant] }}
-      onClick={onClick}
-      disabled={disabled}
-    >
-      {label}
-    </button>
-  );
-};
-
-export default Button;
-''';
-    with open(components_dir / "Button.tsx", 'w') as f {
-        f.write(button_tsx_content);
+"""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;
     }
-    print("Created src/components/Button.tsx");
-
-    readme_content = f'''  # {project_name}
-
-
-A Jac client-side application with React and TypeScript support.
-
-## Project Structure
-
-```
-{project_name}/
-├── jac.toml              # Project configuration
-├── src/                  # Source files
-│   ├── app.jac           # Main application entry
-│   └── components/       # Reusable components
-│       └── Button.tsx    # Example TypeScript component
-├── assets/               # Static assets (images, fonts, etc.)
-└── build/                # Build output (generated)
-```
-
-## Getting Started
-
-Start the development server:
-
-```bash
-jac serve src/app.jac
-```
-
-## TypeScript Support
 
-Create TypeScript components in `src/components/` and import them in your Jac files:
+    # Store target info in context for use by build handler
+    ctx.set_data("build_target", target);
+    ctx.set_data("build_platform", platform);
 
-```jac
-cl import from "./components/Button.tsx" {{ Button }}
-```
+    # 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."
+        );
+    }
 
-## Adding Dependencies
+    # 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;
+        }
 
-Add npm packages with the --cl flag:
+        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;
+        }
 
-```bash
-jac add --cl react-router-dom
-```
-''';
-    with open(project_path / "README.md", 'w') as f {
-        f.write(readme_content);
+        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);
     }
-    print("Created README.md");
+}
 
-    _create_gitignore(project_path, client=True);
+"""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 }
 
-    # Install default packages unless --skip is specified
-    if not skip {
-        print("\nInstalling default packages...");
-        _install_default_packages(project_path, verbose);
-    }
+    target_name = ctx.get_arg("client", "web");
 
-    print(f"\nProject '{project_name}' created successfully!");
-    if name and name != cwd.name {
-        print("\nNext steps:");
-        print(f"  cd {name}");
-        print("  jac serve src/app.jac");
-    } else {
-        print("\nNext steps:");
-        print("  jac serve src/app.jac");
-    }
-}
+    registry = get_target_registry();
+    target = registry.get(target_name);
 
-"""Create .gitignore file with appropriate entries."""
-def _create_gitignore(project_path: pathlib.Path, client: bool = False) -> None {
-    gitignore_entries = [
-        "# Jac project",
-        "packages/",
-        ".jac_cache/",
-        "*.jbc",
-        "*.jir",
-        "__jaccache__/",
-        "",
-        "# Python",
-        "__pycache__/",
-        "*.py[cod]",
-        ".venv/",
-        "venv/",
-        "",
-        "# IDE",
-        ".idea/",
-        ".vscode/",
-        "*.swp"
-    ];
-
-    if client {
-        gitignore_entries.extend(
-            [
-                "",
-                "# Node.js",
-                "node_modules/",
-                "",
-                "# Jac Client",
-                ".client-build/",
-                "*.session",
-                "*.session.*"
-            ]
+    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;
     }
 
-    gitignore_path = project_path / ".gitignore";
-    if gitignore_path.exists() {
-        with open(gitignore_path, "r") as f {
-            existing_content = f.read();
+    # 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;
         }
-        new_entries: list = [];
-        for entry in gitignore_entries {
-            if entry and entry not in existing_content {
-                new_entries.append(entry);
-            }
+        # Get entry file
+        entry_file = ctx.get_arg("filename", None);
+        if not entry_file {
+            entry_file = config.entry_point;
         }
-        if new_entries {
-            with open(gitignore_path, "a") as f {
-                f.write("\n" + "\n".join(new_entries));
-            }
-            print("Updated .gitignore");
+        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;
         }
-    } else {
-        with open(gitignore_path, "w") as f {
-            f.write("\n".join(gitignore_entries) + "\n");
+        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;
         }
-        print("Created .gitignore");
+        # 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)
 }
 
-"""Install default npm packages in .client-build directory."""
-def _install_default_packages(
-    project_path: pathlib.Path, verbose: bool = False
-) -> None {
-    import from jac_client.plugin.src.vite_bundler { ViteBundler }
+"""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 {
-        # 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
-            );
+        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 project name from jac.toml or use directory name
-        project_name = project_path.name;
-
-        # Create ViteBundler instance (it will load config internally)
-        bundler = ViteBundler(project_path);
-
-        # Generate package.json with default packages (defaults are added automatically)
-        bundler.create_package_json(project_name=project_name);
-
-        # Ensure .client-build directory exists
-        build_dir = project_path / '.client-build';
-        build_dir.mkdir(parents=True, exist_ok=True);
-
-        # Copy package.json to .client-build/ for npm install
-        configs_package_json = build_dir / '.jac-client.configs' / 'package.json';
-        build_package_json = build_dir / 'package.json';
+        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);
 
-        if not configs_package_json.exists() {
-            print(
-                "Warning: package.json was not generated, skipping package installation",
-                file=sys.stderr
+        # 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;
         }
 
-        # Always copy the generated package.json to .client-build/ for npm install
-        shutil.copy2(configs_package_json, build_package_json);
+        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);
+    }
+}
 
-        # Read package data for verbose output
-        import json;
-        with open(configs_package_json, 'r') as f {
-            pkg_data = json.load(f);
-        }
-        deps = pkg_data.get('dependencies', {});
-        dev_deps = pkg_data.get('devDependencies', {});
-
-        if verbose {
-            # Verbose mode: show detailed package list and stream npm output
-            if deps {
-                print("  Dependencies:");
-                for (name, version) in deps.items() {
-                    print(f"    - {name}@{version}");
-                }
-            }
-            if dev_deps {
-                print("  Dev dependencies:");
-                for (name, version) in dev_deps.items() {
-                    print(f"    - {name}@{version}");
-                }
-            }
-            print("\nRunning npm install...");
-        }
+"""Pre-hook to handle --npm flag for removing npm dependencies."""
+def _handle_npm_remove(ctx: HookContext) -> None {
+    # Check if --npm flag is set
+    npm_flag = ctx.get_arg("npm", False);
+    if not npm_flag {
+        # Let core remove command run normally
+        return;
+    }
 
-        # Run npm install in .client-build/ directory
-        try {
-            if verbose {
-                # Stream output for visibility in verbose mode
-                subprocess.run(
-                    ['npm', 'install', '--progress'], cwd=build_dir, check=True
-                );
-            } else {
-                # Quiet mode: capture output
-                subprocess.run(
-                    ['npm', 'install'],
-                    cwd=build_dir,
-                    check=True,
-                    capture_output=True,
-                    text=True
-                );
-            }
+    import from jaclang.project.config { get_config }
+    import from jaclang.project.dep_registry { get_dependency_registry }
+    import from jaclang.cli.console { console }
 
-            # Move package-lock.json to .jac-client.configs/ if it was created
-            build_package_lock = build_dir / 'package-lock.json';
-            configs_dir = build_dir / '.jac-client.configs';
-            configs_package_lock = configs_dir / 'package-lock.json';
-            if build_package_lock.exists() {
-                configs_dir.mkdir(parents=True, exist_ok=True);
-                if configs_package_lock.exists() {
-                    configs_package_lock.unlink();
-                }
-                shutil.move(str(build_package_lock), str(configs_package_lock));
-            }
+    config = get_config();
+    if config is None {
+        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;
+    }
 
-            print("Default packages installed successfully");
-        } except subprocess.CalledProcessError as e {
-            if verbose {
-                print(
-                    f"Warning: Failed to install packages (exit code {e.returncode})",
-                    file=sys.stderr
-                );
-            } else {
-                print(
-                    f"Warning: Failed to install packages: {e.stderr}", file=sys.stderr
-                );
-            }
-            print("You can install packages later with: jac add --cl", file=sys.stderr);
-        } except FileNotFoundError {
-            print(
-                "Warning: npm command not found. Install Node.js and npm to install packages.",
-                file=sys.stderr
-            );
-            print("You can install packages later with: jac add --cl", file=sys.stderr);
-        } finally {
-            # Clean up temporary package.json in .client-build/
-            if build_package_json.exists() {
-                build_package_json.unlink();
-            }
+    packages = ctx.get_arg("packages", []);
+    if not packages {
+        console.error("No packages specified.");
+        ctx.set_data("cancel_execution", True);
+        ctx.set_data("cancel_return_code", 1);
+        return;
+    }
+
+    registry = get_dependency_registry();
+    dep_type = registry.get_by_flag("--npm");
+    if dep_type is None {
+        console.error("--npm flag requires jac-client plugin to be installed.");
+        console.print("Install with: pip install jac-client", style="muted");
+        ctx.set_data("cancel_execution", True);
+        ctx.set_data("cancel_return_code", 1);
+        return;
+    }
+
+    dev = ctx.get_arg("dev", False);
+
+    try {
+        for name in packages {
+            console.info(f"Removing {name} ({dep_type.name})...");
+            dep_type.remove_handler(config, name, dev);
         }
+        console.success(f"Removed {len(packages)} package(s)");
+        ctx.set_data("cancel_execution", True);
+        ctx.set_data("cancel_return_code", 0);
     } except Exception as e {
-        print(f"Warning: Could not install default packages: {e}", file=sys.stderr);
-        print("You can install packages later with: jac add --cl", file=sys.stderr);
+        console.error(f"Error removing packages: {e}");
+        ctx.set_data("cancel_execution", True);
+        ctx.set_data("cancel_return_code", 1);
     }
 }