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

jac_client/plugin/cli.jac

@@ -1,504 +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 using the extend_command API.
+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.registry { get_registry }
 import from jaclang.cli.command { Arg, ArgKind, HookContext }
 import from jaclang.pycore.runtime { hookimpl }
-import from jaclang.project.config { 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 {
-        """Extend core create command to add --cl flag for client-side setup.""";
+        """Extend core commands to add --npm flag for npm package management.""";
         registry = get_registry();
 
-        # Extend the core 'create' command with client-specific arguments
+        # Extend the core 'create' command with --skip flag for client template
         registry.extend_command(
             command_name="create",
             args=[
                 Arg.create(
-                    "cl",
+                    "skip",
                     typ=bool,
                     default=False,
-                    help="Include client-side (frontend) setup",
-                    short="c"
+                    help="Skip npm package installation (for --use client)"
                 ),
+
+            ],
+            pre_hook=_handle_create_skip,
+            source="jac-client"
+        );
+
+        # Extend the core 'add' command with --npm flag
+        registry.extend_command(
+            command_name="add",
+            args=[
                 Arg.create(
-                    "skip",
+                    "npm",
                     typ=bool,
                     default=False,
-                    help="Skip installing default packages (only for --cl)",
-                    short="s"
+                    help="Add as npm (client-side) dependency"
                 ),
+
+            ],
+            pre_hook=_handle_npm_add,
+            source="jac-client"
+        );
+
+        # Extend the core 'remove' command with --npm flag
+        registry.extend_command(
+            command_name="remove",
+            args=[
                 Arg.create(
-                    "verbose",
+                    "npm",
                     typ=bool,
                     default=False,
-                    help="Show detailed output during installation",
-                    short="v"
+                    help="Remove npm (client-side) dependency"
                 ),
 
             ],
-            pre_hook=_handle_client_create,
+            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"
+            );
+        }
+    }
+}
+
+"""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
 }
 
-"""Pre-hook to handle --cl flag for client-side project creation."""
-def _handle_client_create(ctx: HookContext) -> None {
-    # Check if --cl flag is set
-    cl_flag = ctx.get_arg("cl", False);
-    if not cl_flag {
-        # Let core create command run normally
+"""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;
     }
 
-    # Handle client-side project creation
-    cwd = pathlib.Path(os.getcwd());
-    name = ctx.get_arg("name", "main");
-    force = ctx.get_arg("force", False);
-    skip_install = ctx.get_arg("skip", False);
-    verbose = ctx.get_arg("verbose", False);
+    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 }
 
-    try {
-        _create_client_project(cwd, name, force, skip_install, verbose);
-        # Cancel core handler with success code
-        ctx.set_data("cancel_execution", True);
-        ctx.set_data("cancel_return_code", 0);
-    } except SystemExit as e {
-        # Preserve exit code from sys.exit() calls
-        ctx.set_data("cancel_execution", True);
-        ctx.set_data("cancel_return_code", e.code if e.code is not None else 1);
-    } except Exception as e {
-        print(f"Error creating client project: {e}", file=sys.stderr);
+    config = get_config();
+    if config is None {
+        console.error(
+            "No jac.toml found", hint="Run 'jac create' to create a project."
+        );
         ctx.set_data("cancel_execution", True);
         ctx.set_data("cancel_return_code", 1);
+        return;
     }
-}
 
-"""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
+    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;
     }
 
-    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
-        );
-        <>exit(1);
-    }
+    packages = ctx.get_arg("packages", []);
+    dev = ctx.get_arg("dev", False);
 
-    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);
+    # 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;
+        }
+        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;
     }
 
-    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);
+    # 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");
         }
-        project_path.mkdir(parents=True, exist_ok=True);
-    } else {
-        project_path = cwd;
+        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(f"Creating Jac client application: {project_name}");
-
-    components_dir = project_path / "components";
-    components_dir.mkdir(parents=True, exist_ok=True);
-
-    assets_dir = project_path / "assets";
-    assets_dir.mkdir(parents=True, exist_ok=True);
-
-    (project_path / ".jac" / "client").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 = "main.jac"
+"""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;
+    }
 
-[dependencies]
+    # Store target info in context for use by build handler
+    ctx.set_data("build_target", target);
+    ctx.set_data("build_platform", platform);
 
-[dependencies.npm]
-"jac-client-node" = "1.0.3"
+    # 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."
+        );
+    }
 
-[dependencies.npm.dev]
-"@jac-client/dev-deps" = "1.0.0"
+    # 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;
+        }
 
-[dev-dependencies]
-watchdog = ">=3.0.0"
+        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;
+        }
 
-[serve]
-base_route_app = "app"
+        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);
 
-[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}");
-
-    main_jac_content = '''"""Main entry point for the Jac client application."""
-
-# Client-side imports (useState is auto-injected when using `has` variables)
-cl import from react { useEffect }
-cl import from .components.Button { Button }
-
-# Client-side component
-cl {
-    def:pub app() -> any {
-        has count: int = 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 { count = count + 1; }}
-                    variant="primary"
-                />
-                <Button
-                    label="Reset"
-                    onClick={lambda -> None { count = 0; }}
-                    variant="secondary"
-                />
-            </div>
-        </div>;
-    }
-}
-''';
-    with open(project_path / "main.jac", 'w') as f {
-        f.write(main_jac_content);
+        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 main.jac");
-
-    button_cl_jac_content = '''"""Button component for the Jac client application."""
-
-def:pub Button(label: str, onClick: any, variant: str = "primary", disabled: bool = False) -> any {
-    base_styles = {
-        "padding": "0.75rem 1.5rem",
-        "fontSize": "1rem",
-        "fontWeight": "600",
-        "borderRadius": "0.5rem",
-        "border": "none",
-        "cursor": "not-allowed" if disabled else "pointer",
-        "transition": "all 0.2s ease"
-    };
-
-    variant_styles = {
-        "primary": {
-            "backgroundColor": "#9ca3af" if disabled else "#3b82f6",
-            "color": "#ffffff"
-        },
-        "secondary": {
-            "backgroundColor": "#e5e7eb" if disabled else "#6b7280",
-            "color": "#ffffff"
-        }
-    };
-
-    return <button
-        style={{**base_styles, **variant_styles[variant]}}
-        onClick={onClick}
-        disabled={disabled}
-    >
-        {label}
-    </button>;
 }
-''';
-    with open(components_dir / "Button.cl.jac", 'w') as f {
-        f.write(button_cl_jac_content);
-    }
-    print("Created components/Button.cl.jac");
-
-    readme_content = f'''  # {project_name}
-
-
-A Jac client-side application with React support.
-
-## Project Structure
-
-```
-{project_name}/
-├── jac.toml              # Project configuration
-├── main.jac              # Main application entry
-├── components/           # Reusable components
-│   └── Button.cl.jac     # Example Jac component
-├── assets/               # Static assets (images, fonts, etc.)
-└── build/                # Build output (generated)
-```
-
-## Getting Started
-
-Start the development server:
-
-```bash
-jac start main.jac
-```
 
-## Components
+"""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 }
 
-Create Jac components in `components/` as `.cl.jac` files and import them:
+    target_name = ctx.get_arg("client", "web");
 
-```jac
-cl import from .components.Button {{ Button }}
-```
+    registry = get_target_registry();
+    target = registry.get(target_name);
 
-## Adding Dependencies
-
-Add npm packages with the --cl flag:
-
-```bash
-jac add --cl react-router-dom
-```
-''';
-    with open(project_path / "README.md", 'w') as f {
-        f.write(readme_content);
-    }
-    print("Created README.md");
-
-    _create_gitignore(project_path);
-
-    # Install default packages unless --skip is specified
-    if not skip {
-        print("\nInstalling default packages...");
-        _install_default_packages(project_path, verbose);
-    }
-
-    print(f"\nProject '{project_name}' created successfully!");
-    if name and name != cwd.name {
-        print("\nNext steps:");
-        print(f"  cd {name}");
-        print("  jac start main.jac");
-    } else {
-        print("\nNext steps:");
-        print("  jac start main.jac");
+    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;
     }
-}
 
-"""Create .gitignore file with client-specific entries."""
-def _create_gitignore(project_path: pathlib.Path) -> None {
-    gitignore_entries = [
-        "# Jac project",
-        "packages/",
-        ".jac_cache/",
-        "*.jbc",
-        "*.jir",
-        "__jaccache__/",
-        "",
-        "# Python",
-        "__pycache__/",
-        "*.py[cod]",
-        ".venv/",
-        "venv/",
-        "",
-        "# IDE",
-        ".idea/",
-        ".vscode/",
-        "*.swp",
-        "",
-        "# Node.js",
-        "node_modules/",
-        "",
-        "# Jac build artifacts",
-        ".jac/",
-        "*.session",
-        "*.session.*"
-    ];
-
-    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;
+        }
+        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;
         }
-    } else {
-        with open(gitignore_path, "w") as f {
-            f.write("\n".join(gitignore_entries) + "\n");
+        # 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);
         }
-        print("Created .gitignore");
+        return;
     }
+    # Web target: let existing start command handle it
+    # (no cancellation, let it run normally)
 }
 
-"""Install default npm packages in .jac/client 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 .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';
+        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 .jac/client/ 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 .jac/client/ directory
-        try {
-            if verbose {
-                # Stream output for visibility in verbose mode
-                subprocess.run(
-                    ['npm', 'install', '--progress'], cwd=client_dir, check=True
-                );
-            } else {
-                # Quiet mode: capture output
-                subprocess.run(
-                    ['npm', 'install'],
-                    cwd=client_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 configs/ if it was created
-            build_package_lock = client_dir / 'package-lock.json';
-            configs_dir = client_dir / '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 .jac/client/
-            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);
     }
 }