jac-client 0.2.12__py3-none-any.whl → 0.2.14__py3-none-any.whl

jac_client/plugin/impl/client_runtime.impl.jac

@@ -1,4 +1,4 @@
-impl __jacJsx(tag: any, props: dict = {}, children: any = []) -> any {
+impl __jacJsx(tag: any, props: dict = {}, children: any = []) -> JsxElement {
     if tag == None {
         tag = React.Fragment;
     }
@@ -42,14 +42,22 @@ impl useRouter -> dict {
 }
 
 impl navigate(path: str) -> None {
-    window.location.hash = "#" + path;
+    window.history.pushState({}, "", path);
+    window.dispatchEvent(Reflect.construct(PopStateEvent, ["popstate"]));
+}
+
+impl __getApiBaseUrl -> str {
+    # globalThis.__JAC_API_BASE_URL__ is replaced by Vite's define at build time.
+    # Falls back to empty string (same-origin) when not configured.
+    return globalThis.__JAC_API_BASE_URL__ || "";
 }
 
 impl __jacSpawn(left: str, right: str = "", fields: dict = {}) -> any {
     token = __getLocalStorage("jac_token");
-    url = f"/walker/{left}";
+    base_url = __getApiBaseUrl();
+    url = f"{base_url}/walker/{left}";
     if right != "" {
-        url = f"/walker/{left}/{right}";
+        url = f"{base_url}/walker/{left}/{right}";
     }
     response = await fetch(
         url,
@@ -78,8 +86,9 @@ impl jacSpawn(left: str, right: str = "", fields: dict = {}) -> any {
 
 impl __jacCallFunction(function_name: str, args: dict = {}) -> any {
     token = __getLocalStorage("jac_token");
+    base_url = __getApiBaseUrl();
     response = await fetch(
-        f"/function/{function_name}",
+        f"{base_url}/function/{function_name}",
         {
             "method": "POST",
             "headers": {
@@ -104,8 +113,9 @@ impl __jacCallFunction(function_name: str, args: dict = {}) -> any {
 }
 
 impl jacSignup(username: str, password: str) -> dict {
+    base_url = __getApiBaseUrl();
     response = await fetch(
-        "/user/register",
+        f"{base_url}/user/register",
         {
             "method": "POST",
             "headers": {"Content-Type": "application/json"},
@@ -140,8 +150,9 @@ impl jacSignup(username: str, password: str) -> dict {
 }
 
 impl jacLogin(username: str, password: str) -> bool {
+    base_url = __getApiBaseUrl();
     response = await fetch(
-        "/user/login",
+        f"{base_url}/user/login",
         {
             "method": "POST",
             "headers": {"Content-Type": "application/json"},
@@ -194,6 +205,17 @@ impl __removeLocalStorage(key: str) -> None {
     }
 }
 
+"""Auth guard component for file-based routing. Renders child routes if
+authenticated, otherwise redirects to the login path."""
+impl AuthGuard(redirect: str = "/login") -> any {
+    if jacIsLoggedIn() {
+        return
+            <ReactRouterOutlet />;
+    }
+    return
+        <ReactRouterNavigate to={redirect} replace={True} />;
+}
+
 impl ErrorFallback(error: str, resetErrorBoundary: any) -> any {
     return
         <div

jac_client/plugin/plugin_config.jac

@@ -10,7 +10,6 @@ configuration system, registering:
 
 import os;
 import subprocess;
-import sys;
 import json;
 import from pathlib { Path }
 import from typing { Any }
@@ -147,9 +146,7 @@ def _load_template(template_name: str) -> dict[str, Any] | None {
 
         return data;
     } except Exception as e {
-        print(
-            f"Warning: Could not load {template_name} template: {e}", file=sys.stderr
-        );
+        console.error(f"Warning: Could not load {template_name} template: {e}");
         return None;
     }
 }
@@ -191,10 +188,7 @@ def _post_create_client(project_path: Path, project_name: str) -> None {
         # 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
-            );
+            console.error("Warning: jac.toml not found, skipping package installation");
             return;
         }
 
@@ -213,9 +207,8 @@ def _post_create_client(project_path: Path, project_name: str) -> None {
         build_package_json = client_dir / 'package.json';
 
         if not configs_package_json.exists() {
-            print(
-                "Warning: package.json was not generated, skipping package installation",
-                file=sys.stderr
+            console.error(
+                "Warning: package.json was not generated, skipping package installation"
             );
             return;
         }

jac_client/plugin/src/compiler.jac

@@ -8,6 +8,7 @@ import from jaclang.runtimelib.client_bundle { ClientBundleError }
 import from .asset_processor { AssetProcessor }
 import from .import_processor { ImportProcessor }
 import from .jac_to_js { JacToJSCompiler }
+import from .route_scanner { RouteScanner, RouteEntry }
 import from .vite_bundler { ViteBundler }
 
 with entry {
@@ -23,12 +24,16 @@ class ViteCompiler {
             'Route',
             'Link',
             'Navigate',
+            'Outlet',
             'useNavigate',
             'useLocation',
-            'useParams'
+            'useParams',
+            'AuthGuard'
         ];
+        COMPOUND_EXTENSIONS = ['.cl.jac', '.impl.jac', '.test.jac'];
     }
 
+    def _jac_path_to_js(self: ViteCompiler, rel_str: str) -> str;
     def init(
         self: ViteCompiler,
         vite_package_json: Path,
@@ -60,7 +65,20 @@ class ViteCompiler {
 
     def copy_root_assets(self: ViteCompiler) -> None;
     def create_entry_file(self: ViteCompiler, module_path: Path) -> None;
+    def _create_pages_entry_content(self: ViteCompiler, module_path: Path) -> str;
+    def _scan_and_compile_pages(
+        self: ViteCompiler,
+        visited: (set[Path] | None) = None,
+        collected_exports: (set[str] | None) = None,
+        collected_globals: (dict[(str, Any)] | None) = None
+    ) -> bool;
+
+    def _generate_routes_manifest(self: ViteCompiler) -> None;
     def compile_and_bundle(
         self: ViteCompiler, module: ModuleType, module_path: Path
     ) -> tuple[str, str, list[str], list[str]];
+
+    def compile(
+        self: ViteCompiler, module: ModuleType, module_path: Path
+    ) -> tuple[list[str], list[str]];
 }

jac_client/plugin/src/config_loader.jac

@@ -19,6 +19,7 @@ class JacClientConfig(PluginConfigBase) {
     override def get_default_config(self: JacClientConfig) -> dict[str, Any];
     override def load(self: JacClientConfig) -> dict[str, Any];
     def save(self: JacClientConfig) -> None;
+    def get_api_config(self: JacClientConfig) -> dict[str, Any];
     def get_vite_config(self: JacClientConfig) -> dict[str, Any];
     def get_ts_config(self: JacClientConfig) -> dict[str, Any];
     def get_configs(self: JacClientConfig) -> dict[str, Any];

jac_client/plugin/src/impl/compiler.impl.jac

@@ -12,18 +12,26 @@ impl ViteCompiler._get_client_dir(self: ViteCompiler) -> Path {
     return self.project_dir / '.jac' / 'client';
 }
 
-"""Compile module and dependencies, then bundle with Vite."""
-impl ViteCompiler.compile_and_bundle(
+"""Compile module and dependencies without bundling (for dev mode)."""
+impl ViteCompiler.compile(
     self: ViteCompiler, module: ModuleType, module_path: Path
-) -> tuple[str, str, list[str], list[str]] {
+) -> tuple[list[str], list[str]] {
     (module_js, mod, module_manifest) = self.jac_compiler.compile_module(module_path);
     collected_exports: set[str] = set(
         self.jac_compiler.extract_exports(module_manifest)
     );
     client_globals_map = self.jac_compiler.extract_globals(module_manifest, module);
     collected_globals: dict[(str, Any)] = dict(client_globals_map);
+    visited: set[Path] = set();
     self.compile_dependencies_recursively(
         module_path,
+        visited=visited,
+        collected_exports=collected_exports,
+        collected_globals=collected_globals
+    );
+    # Scan pages/ directory for file-based routing (compiles page files too)
+    self._has_pages = self._scan_and_compile_pages(
+        visited=visited,
         collected_exports=collected_exports,
         collected_globals=collected_globals
     );
@@ -32,13 +40,22 @@ impl ViteCompiler.compile_and_bundle(
     self.compile_runtime_utils();
     self.copy_root_assets();
     self.create_entry_file(module_path);
+    # Return exports and globals without bundling
+    client_exports = sorted(collected_exports);
+    client_globals = list(collected_globals.keys());
+    return (client_exports, client_globals);
+}
+
+"""Compile module and dependencies, then bundle with Vite."""
+impl ViteCompiler.compile_and_bundle(
+    self: ViteCompiler, module: ModuleType, module_path: Path
+) -> tuple[str, str, list[str], list[str]] {
+    (client_exports, client_globals) = self.compile(module, module_path);
     # Vite handles JSX/TSX transpilation natively with Bun - no Babel needed
     # Vite builds directly from compiled/ directory
     entry_file = self.compiled_dir / '_entry.js';
     self.vite_bundler.build(entry_file=entry_file);
     (bundle_code, bundle_hash) = self.vite_bundler.read_bundle();
-    client_exports = sorted(collected_exports);
-    client_globals = list(collected_globals.keys());
     return (bundle_code, bundle_hash, client_exports, client_globals);
 }
 
@@ -46,12 +63,110 @@ impl ViteCompiler.compile_and_bundle(
 impl ViteCompiler.create_entry_file(self: ViteCompiler, module_path: Path) -> None {
     # Use _entry.js to avoid conflict with compiled modules that may be named main.js
     entry_file = self.compiled_dir / '_entry.js';
-    # Derive the app module filename from the entry point (e.g., main.jac -> main.js, app.jac -> app.js)
-    app_module_name = module_path.stem;
-    entry_content = f'import React from "react";\nimport {{ createRoot }} from "react-dom/client";\nimport {{ app as App }} from "./{app_module_name}.js";\nimport {{ JacClientErrorBoundary, ErrorFallback }} from "@jac/runtime";\n\nconst root = createRoot(document.getElementById("root"));\nroot.render(\n\tReact.createElement(\n\t\tJacClientErrorBoundary,{{ FallbackComponent: ErrorFallback }},\n\t\tReact.createElement(App, null)\n\t)\n);\n';
+    if self._has_pages {
+        # File-based routing mode: import from generated _routes.js
+        entry_content = self._create_pages_entry_content(module_path);
+    } else {
+        # Explicit routing mode: import app from entry module (original behavior)
+        app_module_name = module_path.stem;
+        entry_content = f'import React from "react";\nimport {{ createRoot }} from "react-dom/client";\nimport {{ app as App }} from "./{app_module_name}.js";\nimport {{ JacClientErrorBoundary, ErrorFallback }} from "@jac/runtime";\n\nconst root = createRoot(document.getElementById("root"));\nroot.render(\n\tReact.createElement(\n\t\tJacClientErrorBoundary,{{ FallbackComponent: ErrorFallback }},\n\t\tReact.createElement(App, null)\n\t)\n);\n';
+    }
     entry_file.write_text(entry_content, encoding='utf-8');
 }
 
+impl ViteCompiler._create_pages_entry_content(
+    self: ViteCompiler, module_path: Path
+) -> str {
+    lines: list[str] = [];
+    auth_redirect = "/login";
+    try {
+        import from ..config_loader { PluginConfig }
+        config = PluginConfig.load(self.project_dir);
+        if config and config?.routing and config.routing {
+            auth_redirect = config.routing.get('auth_redirect', '/login');
+        }
+    } except Exception { }
+    # Check if main.jac exists and exports app (used as wrapper)
+    app_module = self.compiled_dir / f"{module_path.stem}.js";
+    has_app_wrapper = app_module.exists();
+    # --- Imports ---
+    lines.append('import React from "react";');
+    lines.append('import { createRoot } from "react-dom/client";');
+    lines.append('import { BrowserRouter, Routes, Route } from "react-router-dom";');
+    lines.append(
+        'import { JacClientErrorBoundary, ErrorFallback, AuthGuard } from "@jac/runtime";'
+    );
+    lines.append('import { routes, layouts } from "./_routes.js";');
+    if has_app_wrapper {
+        lines.append(f'import {{ app as AppWrapper }} from "./{module_path.stem}.js";');
+    }
+    lines.append('');
+    # --- Route helpers ---
+    lines.append('const publicRoutes = routes.filter(r => !r.auth);');
+    lines.append('const authRoutes = routes.filter(r => r.auth);');
+    lines.append('const RootLayout = layouts["/"] || null;');
+    lines.append('');
+    lines.append('function renderRoutes(routeList) {');
+    lines.append('\treturn routeList.map(r =>');
+    lines.append(
+        '\t\tReact.createElement(Route, { key: r.path, path: r.path, element: React.createElement(r.element, null) })'
+    );
+    lines.append('\t);');
+    lines.append('}');
+    lines.append('');
+    # --- Auth guard routes (reused in both layout and non-layout paths) ---
+    # AuthGuard is a runtime function compiled with plain parameters (not React props
+    # destructuring), so we wrap it in a component that passes the redirect string directly.
+    lines.append(
+        f'function _AuthGuardRoute() {{ return AuthGuard("{auth_redirect}"); }}'
+    );
+    lines.append(
+        'const authGuardElement = React.createElement(_AuthGuardRoute, null);'
+    );
+    lines.append('');
+    # --- Single App component with one BrowserRouter ---
+    lines.append('function App() {');
+    lines.append('\tconst routeChildren = [');
+    lines.append('\t\t...renderRoutes(publicRoutes),');
+    lines.append(
+        '\t\tReact.createElement(Route, { key: "__auth", element: authGuardElement },'
+    );
+    lines.append('\t\t\t...renderRoutes(authRoutes)');
+    lines.append('\t\t),');
+    lines.append('\t];');
+    lines.append('');
+    lines.append('\tconst routeTree = RootLayout');
+    lines.append(
+        '\t\t? React.createElement(Route, { element: React.createElement(RootLayout, null) }, ...routeChildren)'
+    );
+    lines.append('\t\t: routeChildren;');
+    lines.append('');
+    lines.append('\treturn React.createElement(BrowserRouter, null,');
+    lines.append('\t\tReact.createElement(Routes, null,');
+    lines.append('\t\t\t...(Array.isArray(routeTree) ? routeTree : [routeTree])');
+    lines.append('\t\t)');
+    lines.append('\t);');
+    lines.append('}');
+    lines.append('');
+    # --- Root render ---
+    if has_app_wrapper {
+        lines.append(
+            'const appElement = React.createElement(AppWrapper, null, React.createElement(App, null));'
+        );
+    } else {
+        lines.append('const appElement = React.createElement(App, null);');
+    }
+    lines.append('');
+    lines.append('const root = createRoot(document.getElementById("root"));');
+    lines.append('root.render(');
+    lines.append(
+        '\tReact.createElement(JacClientErrorBoundary, { FallbackComponent: ErrorFallback }, appElement)'
+    );
+    lines.append(');');
+    lines.append('');
+    return "\n".join(lines);
+}
+
 """Copy assets from root assets/ folder to compiled/assets/ for @jac-client/assets alias."""
 impl ViteCompiler.copy_root_assets(self: ViteCompiler) -> None {
     root_assets_dir = self.project_dir / 'assets';
@@ -162,45 +277,14 @@ impl ViteCompiler.compile_dependencies_recursively(
     combined_js = self.jac_compiler.add_runtime_imports(module_js);
     try {
         relative_path = module_path.relative_to(source_root);
-        # Handle compound extensions like .cl.jac, .impl.jac -> .js
-        rel_str = str(relative_path);
-        for compound_ext in ['.cl.jac', '.impl.jac', '.test.jac'] {
-            if rel_str.endswith(compound_ext) {
-                rel_str = rel_str[:-len(compound_ext)] + '.js';
-                break;
-            }
-        } else {
-            rel_str = str(relative_path.with_suffix('.js'));
-        }
+        rel_str = self._jac_path_to_js(str(relative_path));
         output_path = self.compiled_dir / rel_str;
     } except ValueError {
-        # Handle compound extensions in filename
-        name = module_path.name;
-        for compound_ext in ['.cl.jac', '.impl.jac', '.test.jac'] {
-            if name.endswith(compound_ext) {
-                name = name[:-len(compound_ext)] + '.js';
-                break;
-            }
-        } else {
-            name = module_path.stem + '.js';
-        }
+        name = self._jac_path_to_js(module_path.name);
         output_path = self.compiled_dir / name;
     }
     output_path.parent.mkdir(parents=True, exist_ok=True);
-    # Add source file header comment for better error messages
     source_header = f"/* Source: {module_path} */\n";
-    # Add ES module exports so Vite can resolve named imports between modules
-    module_export_names = sorted(set(exports_list + list(non_root_globals.keys())));
-    if module_export_names {
-        import re;
-        # Strip any existing export declarations to avoid duplicates
-        clean_combined_js = re.sub(r'\nexport\s*\{[^}]*\}\s*;?\s*', '\n', combined_js);
-        clean_combined_js = re.sub(
-            r'\bexport\s+(let|const|var|function|class)\b', r'\1', clean_combined_js
-        );
-        export_stmt = f"\nexport {{ {', '.join(module_export_names)} }};\n";
-        combined_js = clean_combined_js + export_stmt;
-    }
     output_path.write_text(source_header + combined_js, encoding='utf-8');
     if (not manifest or not manifest.imports) {
         return;
@@ -240,34 +324,118 @@ impl ViteCompiler.compile_runtime_utils(self: ViteCompiler) -> tuple[str, list[s
     runtimeutils_exports_list = self.jac_compiler.extract_exports(
         runtimeutils_manifest
     );
-    # Include both function exports and glob exports (e.g., useState, useEffect)
     glob_names = list(runtimeutils_manifest.globals) if runtimeutils_manifest else [];
     all_exports = sorted(
         set(runtimeutils_exports_list + self.ROUTER_EXPORTS + glob_names)
     );
-    # Strip all existing export statements from compiled JS to avoid duplicates.
-    # The codegen produces `export let`, `export function`, `export class`, and
-    # `export { ... }` forms. We remove the export keyword from declarations and
-    # remove export blocks entirely, then add one comprehensive export at the end.
-    import re;
-    clean_js = re.sub(r'\nexport\s*\{[^}]*\}\s*;?\s*', '\n', runtimeutils_js);
-    clean_js = re.sub(r'\bexport\s+(let|const|var|function|class)\b', r'\1', clean_js);
-    # Append single comprehensive ES module export for Vite to resolve @jac/runtime
-    export_names = [
-        e
-        for e in all_exports
-        if not e.startswith('_')
-    ];
-    # Also include internal names that are imported by compiled modules
-    internal_exports = ['__jacJsx', '__jacSpawn', '__jacCallFunction'];
-    all_export_names = sorted(set(export_names + internal_exports));
-    export_stmt = f"\nexport {{ {', '.join(all_export_names)} }};\n";
-    combined_runtime_utils_js = clean_js + export_stmt;
     self.compiled_dir.mkdir(parents=True, exist_ok=True);
     (self.compiled_dir / 'client_runtime.js').write_text(
-        combined_runtime_utils_js, encoding='utf-8'
+        runtimeutils_js, encoding='utf-8'
     );
-    return (combined_runtime_utils_js, all_exports);
+    return (runtimeutils_js, all_exports);
+}
+
+"""Convert a .jac relative path string to .js, handling compound extensions."""
+impl ViteCompiler._jac_path_to_js(self: ViteCompiler, rel_str: str) -> str {
+    for compound_ext in self.COMPOUND_EXTENSIONS {
+        if rel_str.endswith(compound_ext) {
+            return rel_str[:-len(compound_ext)] + '.js';
+        }
+    }
+    return str(Path(rel_str).with_suffix('.js'));
+}
+
+"""Scan pages/ directory, compile page files, and generate _routes.js manifest.
+Returns True if pages/ exists and routes were generated."""
+impl ViteCompiler._scan_and_compile_pages(
+    self: ViteCompiler,
+    visited: (set[Path] | None) = None,
+    collected_exports: (set[str] | None) = None,
+    collected_globals: (dict[(str, Any)] | None) = None
+) -> bool {
+    scanner = RouteScanner(self.project_dir);
+    if not scanner.has_pages_dir() {
+        return False;
+    }
+    routes = scanner.scan();
+    if not routes and not scanner.get_layouts() {
+        return False;
+    }
+    self._route_scanner = scanner;
+    # Compile each page file through the standard pipeline
+    source_root = self.project_dir;
+    for page_file in scanner.get_page_files() {
+        self.compile_dependencies_recursively(
+            page_file,
+            visited=visited,
+            collected_exports=collected_exports,
+            collected_globals=collected_globals,
+            source_root=source_root
+        );
+    }
+    self._generate_routes_manifest();
+    return True;
+}
+
+"""Generate _routes.js manifest from previously scanned route entries."""
+impl ViteCompiler._generate_routes_manifest(self: ViteCompiler) -> None {
+    scanner = self._route_scanner;
+    # Use cached results from _scan_and_compile_pages — don't re-scan
+    routes = scanner._routes;
+    layouts = scanner.get_layouts();
+    lines: list[str] = [];
+    # Import page components
+    for route in routes {
+        if route.is_layout {
+            continue;
+        }
+        # Compute relative import path from pages/ to compiled/pages/
+        try {
+            rel_path = route.file_path.relative_to(self.project_dir);
+        } except ValueError {
+            rel_path = route.file_path.relative_to(scanner.pages_dir.parent);
+        }
+        rel_str = self._jac_path_to_js(str(rel_path));
+        lines.append(
+            f'import {{ page as {route.component_import} }} from "./{rel_str}";'
+        );
+    }
+    # Import layout components
+    for (prefix, layout) in layouts.items() {
+        try {
+            rel_path = layout.file_path.relative_to(self.project_dir);
+        } except ValueError {
+            rel_path = layout.file_path.relative_to(scanner.pages_dir.parent);
+        }
+        rel_str = self._jac_path_to_js(str(rel_path));
+        lines.append(
+            f'import {{ layout as {layout.component_import} }} from "./{rel_str}";'
+        );
+    }
+    lines.append('');
+    # Export routes array
+    lines.append('export const routes = [');
+    for route in routes {
+        if route.is_layout {
+            continue;
+        }
+        auth_str = "true" if route.auth_required else "false";
+        lines.append(
+            f'\t{{ path: "{route.path}", element: {route.component_import}, auth: {auth_str} }},'
+        );
+    }
+    lines.append('];');
+    lines.append('');
+    # Export layouts object
+    lines.append('export const layouts = {');
+    for (prefix, layout) in layouts.items() {
+        lines.append(f'\t"{prefix}": {layout.component_import},');
+    }
+    lines.append('};');
+    lines.append('');
+    manifest_path = self.compiled_dir / '_routes.js';
+    manifest_path.parent.mkdir(parents=True, exist_ok=True);
+    manifest_path.write_text("\n".join(lines), encoding='utf-8');
 }
 
 """Initialize the Vite compiler."""
@@ -317,4 +485,6 @@ impl ViteCompiler.init(
     self.import_processor = ImportProcessor();
     self.asset_processor = AssetProcessor();
     self.vite_bundler = ViteBundler(self.project_dir, vite_output_dir, vite_minify);
+    self._has_pages = False;
+    self._route_scanner = None;
 }

jac_client/plugin/src/impl/config_loader.impl.jac

@@ -19,6 +19,7 @@ impl JacClientConfig.get_plugin_name(self: JacClientConfig) -> str {
 """Get default configuration structure for client."""
 impl JacClientConfig.get_default_config(self: JacClientConfig) -> dict[str, Any] {
     return {
+        'api': {'base_url': ''},
         'vite': {
             'plugins': [],
             'lib_imports': [],
@@ -60,6 +61,7 @@ impl JacClientConfig.load(self: JacClientConfig) -> dict[str, Any] {
     else {};
     # Build user config in the expected internal format
     user_config: dict[str, Any] = {
+        'api': client_config.get('api', {}),
         'vite': client_config.get('vite', {}),
         'ts': client_config.get('ts', {}),
         'configs': client_config.get('configs', {}),
@@ -81,6 +83,12 @@ impl JacClientConfig.get_package_config(self: JacClientConfig) -> dict[str, Any]
     return config.get('package', {});
 }
 
+"""Get API configuration (base_url for backend)."""
+impl JacClientConfig.get_api_config(self: JacClientConfig) -> dict[str, Any] {
+    config = self.load();
+    return config.get('api', {});
+}
+
 """Get Vite-specific configuration."""
 impl JacClientConfig.get_vite_config(self: JacClientConfig) -> dict[str, Any] {
     config = self.load();

jac_client/plugin/src/impl/package_installer.impl.jac

@@ -40,6 +40,7 @@ impl PackageInstaller.uninstall_package(
 """Regenerate package.json from jac.toml and run bun install."""
 impl PackageInstaller._regenerate_and_install(self: PackageInstaller) -> None {
     import from jac_client.plugin.utils { ensure_bun_available }
+    import from jaclang.cli.console { console }
     # Ensure bun is available before proceeding
     if not ensure_bun_available() {
         raise ClientBundleError('Bun is required. Install manually: https://bun.sh') from None ;
@@ -51,14 +52,14 @@ impl PackageInstaller._regenerate_and_install(self: PackageInstaller) -> None {
     bundler._ensure_root_package_json();
     try {
         # Run bun install to actually install the packages
-        print("\n  ⏳ Installing packages...\n", flush=True);
+        console.print("\n  ⏳ Installing packages...\n");
         result = subprocess.run(
             ['bun', 'install'], cwd=self.project_dir, check=False, text=True
         );
         if result.returncode != 0 {
             raise ClientBundleError('Failed to install packages (see output above)') ;
         }
-        print("\n  ✔ Packages installed", flush=True);
+        console.print("\n  ✔ Packages installed");
     } finally {
         # Always clean up root package.json and move bun.lockb
         bundler._cleanup_root_package_files();