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

jac_client/plugin/src/impl/vite_bundler.impl.jac

@@ -44,17 +44,14 @@ impl ViteBundler.create_package_json(
     }
     dependencies = package_config.get('dependencies', {});
     dev_dependencies = package_config.get('devDependencies', {});
+    # Vite handles JSX/TSX transpilation natively with Bun - no Babel compile step needed
     scripts = {
-        'build': 'npm run compile && vite build --config .jac/client/configs/vite.config.js',
+        'build': 'vite build --config .jac/client/configs/vite.config.js',
         'dev': 'vite dev --config .jac/client/configs/vite.config.js',
-        'preview': 'vite preview --config .jac/client/configs/vite.config.js',
-        'compile': 'babel compiled --out-dir build --extensions ".jsx,.js" --out-file-extension .js'
+        'preview': 'vite preview --config .jac/client/configs/vite.config.js'
     };
     user_scripts = package_config.get('scripts', {});
     scripts.update(user_scripts);
-    babel_config = {
-        'presets': [['@babel/preset-env', {'modules': False}], '@babel/preset-react']
-    };
     package_data = {
         'name': name,
         'version': package_config.get('version', '1.0.0'),
@@ -63,8 +60,7 @@ impl ViteBundler.create_package_json(
         'main': 'index.js',
         'scripts': scripts,
         'dependencies': dependencies,
-        'devDependencies': dev_dependencies,
-        'babel': babel_config
+        'devDependencies': dev_dependencies
     };
     for (key, value) in package_config.items() {
         if (
@@ -131,22 +127,22 @@ impl ViteBundler.create_tsconfig(self: ViteBundler) -> Path {
 }
 
 """
-Clean up root package.json and move package-lock.json to configs/.
+Clean up root package.json and move bun.lockb to configs/.
 
-        Remove root package.json and move package-lock.json to configs/.
+        Remove root package.json and move bun.lockb to configs/.
 """
 impl ViteBundler._cleanup_root_package_files(self: ViteBundler) -> None {
     root_package_json = self.project_dir / 'package.json';
-    root_package_lock = self.project_dir / 'package-lock.json';
+    root_bun_lockb = self.project_dir / 'bun.lockb';
     build_dir = self._get_client_dir();
     configs_dir = build_dir / 'configs';
-    configs_package_lock = configs_dir / 'package-lock.json';
-    if root_package_lock.exists() {
+    configs_bun_lockb = configs_dir / 'bun.lockb';
+    if root_bun_lockb.exists() {
         configs_dir.mkdir(exist_ok=True);
-        if configs_package_lock.exists() {
-            configs_package_lock.unlink();
+        if configs_bun_lockb.exists() {
+            configs_bun_lockb.unlink();
         }
-        shutil.move(str(root_package_lock), str(configs_package_lock));
+        shutil.move(str(root_bun_lockb), str(configs_bun_lockb));
     }
     if root_package_json.exists() {
         root_package_json.unlink();
@@ -154,7 +150,7 @@ impl ViteBundler._cleanup_root_package_files(self: ViteBundler) -> None {
 }
 
 """
-Ensure root package.json exists temporarily for npm commands.
+Ensure root package.json exists temporarily for bun commands.
 
         Create root package.json temporarily if it doesn't exist.
 """
@@ -303,26 +299,76 @@ impl ViteBundler.create_vite_config(self: ViteBundler, entry_file: Path) -> Path
     else '';
     config_content = f'''import {{ defineConfig }} from "vite";
 import path from "path";
+import fs from "fs";
 import {{ fileURLToPath }} from "url";
 {imports_section}const __dirname = path.dirname(fileURLToPath(import.meta.url));
 // Config is in configs/ inside .jac/client/, so go up one level to .jac/client/, then up two more to project root
 const buildDir = path.resolve(__dirname, "..");
 const projectRoot = path.resolve(__dirname, "../../..");
 
+// Jac source mapper plugin - maps errors back to original .jac files
+function jacSourceMapper() {{
+  const sourceMap = new Map(); // compiled path -> original jac path
+
+  return {{
+    name: 'jac-source-mapper',
+    enforce: 'pre',
+
+    // Extract source mapping from compiled files
+    transform(code, id) {{
+      if (id.includes('/compiled/') && id.endsWith('.js')) {{
+        const match = code.match(/^\\/\\* Source: (.+?) \\*\\//);
+        if (match) {{
+          sourceMap.set(id, match[1]);
+        }}
+      }}
+      return null;
+    }},
+
+    // Enhance error messages with original source info
+    buildEnd() {{
+      // Store source map for error reporting
+      this._jacSourceMap = sourceMap;
+    }},
+
+    // Handle resolve errors to show original source
+    resolveId(source, importer) {{
+      if (importer && sourceMap.has(importer)) {{
+        const originalSource = sourceMap.get(importer);
+        // Check for common issues like double slashes
+        if (source.includes('//') && !source.startsWith('http')) {{
+          this.error({{
+            message: `Cannot resolve "${{source}}" - path contains invalid double slash. Check your import in the original Jac file.`,
+            id: originalSource,
+            loc: {{ line: 1, column: 0 }}
+          }});
+        }}
+      }}
+      return null;
+    }}
+  }};
+}}
+
 /**
  * Vite configuration generated from config.json (in project root)
  * To customize, edit config.json instead of this file.
  */
 
 export default defineConfig({{
-  plugins: [{(newline + plugins_str + newline + '  ') if plugins_str else ''}],
+  plugins: [
+    jacSourceMapper(),{(newline + plugins_str + newline + '  ') if plugins_str else ''}],
   root: buildDir, // base folder (.jac/client/) so vite can find node_modules
     build: {{
+    sourcemap: true, // Enable source maps for better error messages
     rollupOptions: {{
       input: path.resolve(buildDir, "{entry_relative}"), // your compiled entry file
       output: {{
         entryFileNames: "client.[hash].js", // name of the final js file
         assetFileNames: (assetInfo) => assetInfo.name?.endsWith('.css') ? 'styles.css' : '[name].[ext]',
+        sourcemapPathTransform: (relativeSourcePath) => {{
+          // Transform source map paths to point to original location
+          return relativeSourcePath;
+        }},
       }},
     }},
     outDir: path.resolve(buildDir, "{output_relative}"), // final bundled output
@@ -332,7 +378,7 @@ export default defineConfig({{
   publicDir: false,
 {server_section}  resolve: {{
       alias: {{
-        "@jac-client/utils": path.resolve(buildDir, "{compiled_utils_relative}"),
+        "@jac/runtime": path.resolve(buildDir, "{compiled_utils_relative}"),
         "@jac-client/assets": path.resolve(buildDir, "{compiled_assets_relative}"),
       }},
       extensions: [{extensions_str}],
@@ -379,19 +425,32 @@ impl ViteBundler.find_bundle(self: ViteBundler) -> Optional[Path] {
 impl ViteBundler.build(self: ViteBundler, entry_file: Optional[Path] = None) -> None {
     import sys;
     import time;
-    self.output_dir.mkdir(parents=True, exist_ok=True);
-    generated_package_json = self._get_client_dir() / 'configs' / 'package.json';
-    if not generated_package_json.exists() {
-        self.create_package_json();
-    } else {
-        # Ensure tsconfig.json exists even if package.json already exists
-        self.create_tsconfig();
+    import shutil;
+    import from jac_client.plugin.utils { ensure_bun_available, ensure_client_deps }
+    # Ensure bun is available before proceeding
+    if not ensure_bun_available() {
+        raise ClientBundleError('Bun is required. Install manually: https://bun.sh') from None ;
+    }
+    # Ensure client npm deps are configured; prompt to install defaults if missing
+    if not ensure_client_deps(self.config_loader) {
+        raise ClientBundleError(
+            'Client dependencies not configured. Add [dependencies.npm] to jac.toml '
+            'or create a project with: jac create --use client'
+        ) from None ;
     }
+    self.output_dir.mkdir(parents=True, exist_ok=True);
+    # Always regenerate package.json to pick up any dependency changes
+    self.create_package_json();
     try {
         build_dir = self._get_client_dir();
         node_modules = build_dir / 'node_modules';
+        # Reinstall if node_modules is missing or stale (e.g. empty from a prior failed install)
+        vite_bin = node_modules / '.bin' / 'vite';
+        if node_modules.exists() and not vite_bin.exists() {
+            shutil.rmtree(node_modules);
+        }
         if not node_modules.exists() {
-            # Temporarily copy package.json to client build dir for npm install
+            # Temporarily copy package.json to client build dir for bun install
             build_package_json = build_dir / 'package.json';
             configs_package_json = build_dir / 'configs' / 'package.json';
             if configs_package_json.exists() and not build_package_json.exists() {
@@ -400,82 +459,82 @@ impl ViteBundler.build(self: ViteBundler, entry_file: Optional[Path] = None) ->
             }
             try {
                 # Install to .jac/client/node_modules with progress feedback
-                print(
-                    "  ⏳ Installing npm dependencies (this may take a minute)...",
-                    flush=True
-                );
+                print("\n  ⏳ Installing dependencies...\n", flush=True);
                 start_time = time.time();
                 result = subprocess.run(
-                    ['npm', 'install', '--progress'],
+                    ['bun', 'install'],
                     cwd=build_dir,
                     check=False,
-                    capture_output=True,
-                    text=True
+                    text=True,
+                    capture_output=True
                 );
                 elapsed = time.time() - start_time;
                 if result.returncode != 0 {
-                    print(
-                        f"\n  ✖ npm install failed after {elapsed:.1f}s",
-                        file=sys.stderr
-                    );
-                    raise ClientBundleError(
-                        f"Failed to install npm dependencies: {result.stderr
-                        or result.stdout}"
-                    ) ;
+                    error_output = result.stderr or result.stdout;
+                    error_msg = f"Dependency installation failed after {elapsed:.1f}s\n\n{error_output}\nCommand: bun install";
+                    raise ClientBundleError(error_msg) from None ;
                 }
-                print(f"  ✔ Dependencies installed ({elapsed:.1f}s)", flush=True);
+                print(f"\n  ✔ Dependencies installed ({elapsed:.1f}s)", flush=True);
             } except FileNotFoundError {
-                raise None from ClientBundleError(
-                    'npm command not found. Ensure Node.js and npm are installed.'
-                ) ;
+                # This shouldn't happen since we check for bun at the start
+                raise ClientBundleError(
+                    'Bun command not found. Install Bun: https://bun.sh'
+                ) from None ;
             }
         }
         if self.config_path {
             # Make config path relative to build_dir (where vite runs from)
             try {
                 config_rel = self.config_path.relative_to(build_dir);
-                command = ['npx', 'vite', 'build', '--config', str(config_rel)];
+                command = ['bun', 'x', 'vite', 'build', '--config', str(config_rel)];
             } except ValueError {
                 # Config is outside client build dir, use absolute path
-                command = ['npx', 'vite', 'build', '--config', str(self.config_path)];
+                command = [
+                    'bun',
+                    'x',
+                    'vite',
+                    'build',
+                    '--config',
+                    str(self.config_path)
+                ];
             }
         } elif entry_file {
             generated_config = self.create_vite_config(entry_file);
             # Config is in configs/, make it relative to build_dir
             config_rel = generated_config.relative_to(build_dir);
-            command = ['npx', 'vite', 'build', '--config', str(config_rel)];
+            command = ['bun', 'x', 'vite', 'build', '--config', str(config_rel)];
         } else {
-            command = ['npm', 'run', 'build'];
+            command = ['bun', 'run', 'build'];
         }
         # Run vite from client build directory so it can find node_modules
-        print("  ⏳ Building client bundle...", flush=True);
+        print("\n  ⏳ Building client bundle...\n", flush=True);
         start_time = time.time();
         result = subprocess.run(
-            command, cwd=build_dir, check=False, capture_output=True, text=True
+            command, cwd=build_dir, check=False, text=True, capture_output=True
         );
         elapsed = time.time() - start_time;
         if result.returncode != 0 {
-            print(f"\n  ✖ Vite build failed after {elapsed:.1f}s", file=sys.stderr);
-            error_msg = result.stderr or result.stdout or 'Unknown error';
-            raise ClientBundleError(
-                f"Vite build failed:\n{error_msg}\nCommand: {' '.join(command)}"
-            ) from None ;
+            error_output = result.stderr or result.stdout;
+            error_msg = f"Vite build failed after {elapsed:.1f}s\n\n{error_output}\nCommand: {' '.join(
+                command
+            )}";
+            raise ClientBundleError(error_msg) from None ;
         }
-        print(f"  ✔ Client bundle built ({elapsed:.1f}s)", flush=True);
+        print(f"\n  ✔ Client bundle built ({elapsed:.1f}s)", flush=True);
     } finally {
         # Clean up temporary package.json in client build dir
         build_package_json = build_dir / 'package.json';
         if build_package_json.exists() {
             build_package_json.unlink();
         }
-        # Move package-lock.json to configs/ if it exists
-        build_package_lock = build_dir / 'package-lock.json';
-        if build_package_lock.exists() {
-            configs_package_lock = build_dir / 'configs' / 'package-lock.json';
-            if configs_package_lock.exists() {
-                configs_package_lock.unlink();
+        # Move bun.lockb to configs/ if it exists
+        build_bun_lockb = build_dir / 'bun.lockb';
+        if build_bun_lockb.exists() {
+            configs_bun_lockb = build_dir / 'configs' / 'bun.lockb';
+            if configs_bun_lockb.exists() {
+                configs_bun_lockb.unlink();
             }
-            build_package_lock.rename(configs_package_lock);
+            build_bun_lockb.rename(configs_bun_lockb);
         }
     }
 }
@@ -543,6 +602,9 @@ export default defineConfig({{
   plugins: [react()],
   root: buildDir,
   publicDir: false,
+  build: {{
+    sourcemap: true, // Enable source maps for better error messages
+  }},
   server: {{
     watch: {{
       usePolling: true,
@@ -565,11 +627,15 @@ export default defineConfig({{
         target: "http://localhost:{api_port}",
         changeOrigin: true,
       }},
+      "/static": {{
+        target: "http://localhost:{api_port}",
+        changeOrigin: true,
+      }},
     }},
   }},
   resolve: {{
     alias: {{
-      "@jac-client/utils": path.resolve(buildDir, "{compiled_utils_relative}"),
+      "@jac/runtime": path.resolve(buildDir, "{compiled_utils_relative}"),
       "@jac-client/assets": path.resolve(buildDir, "{compiled_assets_relative}"),
     }},
     extensions: [{extensions_str}],
@@ -628,6 +694,13 @@ def _toml_config_to_js(config_name: str, config_data: dict) -> str {
 impl ViteBundler.start_dev_server(self: ViteBundler, port: int = 3000) -> Any {
     import sys;
     import time;
+    import from jac_client.plugin.utils { ensure_bun_available }
+    # Ensure bun is available before starting dev server
+    if not ensure_bun_available() {
+        raise ClientBundleError(
+            'Bun is required for dev server. Install manually: https://bun.sh'
+        ) from None ;
+    }
     build_dir = self._get_client_dir();
     node_modules = build_dir / 'node_modules';
     # Create/update index.html for dev server (load from compiled/ for HMR)
@@ -652,36 +725,25 @@ impl ViteBundler.start_dev_server(self: ViteBundler, port: int = 3000) -> Any {
         if not generated_package_json.exists() {
             self.create_package_json();
         }
-        # Temporarily copy package.json for npm install
+        # Temporarily copy package.json for bun install
         build_package_json = build_dir / 'package.json';
         if not build_package_json.exists() {
             shutil.copy2(generated_package_json, build_package_json);
         }
         try {
-            print(
-                "  ⏳ Installing npm dependencies (this may take a minute)...",
-                flush=True
-            );
+            print("\n  ⏳ Installing dependencies...\n", flush=True);
             start_time = time.time();
             result = subprocess.run(
-                ['npm', 'install', '--progress'],
-                cwd=build_dir,
-                check=False,
-                capture_output=True,
-                text=True
+                ['bun', 'install'], cwd=build_dir, check=False, text=True
             );
             elapsed = time.time() - start_time;
             if result.returncode != 0 {
                 print(
-                    f"\n  ✖ npm install failed after {elapsed:.1f}s", file=sys.stderr
+                    f"\n  ✖ bun install failed after {elapsed:.1f}s", file=sys.stderr
                 );
-                print(f"  Error: {result.stderr or result.stdout}", file=sys.stderr);
-                raise ClientBundleError(
-                    f"Failed to install npm dependencies: {result.stderr
-                    or result.stdout}"
-                ) ;
+                raise ClientBundleError("Failed to install dependencies") ;
             }
-            print(f"  ✔ Dependencies installed ({elapsed:.1f}s)", flush=True);
+            print(f"\n  ✔ Dependencies installed ({elapsed:.1f}s)", flush=True);
         } finally {
             # Clean up temp package.json
             if build_package_json.exists() {
@@ -700,7 +762,7 @@ impl ViteBundler.start_dev_server(self: ViteBundler, port: int = 3000) -> Any {
     logger.debug(f"Starting Vite dev server on port {port}");
     # Start Vite in dev mode (let output go to terminal for HMR visibility)
     process = subprocess.Popen(
-        ['npx', 'vite', '--config', str(config_rel), '--port', str(port)],
+        ['bun', 'x', 'vite', '--config', str(config_rel), '--port', str(port)],
         cwd=build_dir
     );
     return process;

jac_client/plugin/src/targets/impl/desktop_target.impl.jac

@@ -1297,17 +1297,14 @@ def _check_and_install_tauri_cli -> None {
         }
     } except Exception { }
 
-    # Check if npm tauri CLI is available
-    npm_tauri_ok = False;
+    # Check if bun tauri CLI is available (global install)
+    bun_tauri_ok = False;
     try {
         result = subprocess.run(
-            ["npm", "list", "-g", "@tauri-apps/cli"],
-            capture_output=True,
-            text=True,
-            timeout=5
+            ["bun", "pm", "ls", "-g"], capture_output=True, text=True, timeout=5
         );
-        if result.returncode == 0 {
-            console.print("  ✔ Tauri CLI found (npm)", style="success");
+        if result.returncode == 0 and "@tauri-apps/cli" in result.stdout {
+            console.print("  ✔ Tauri CLI found (bun)", style="success");
             return;
         }
     } except Exception { }
@@ -1327,22 +1324,22 @@ def _check_and_install_tauri_cli -> None {
         cargo_available = True;
     } except Exception { }
 
-    # Check if npm is available
-    npm_available = False;
+    # Check if bun is available
+    bun_available = False;
     try {
         subprocess.run(
-            ["npm", "--version"], capture_output=True, check=True, timeout=5
+            ["bun", "--version"], capture_output=True, check=True, timeout=5
         );
-        npm_available = True;
+        bun_available = True;
     } except Exception { }
 
-    if not cargo_available and not npm_available {
+    if not cargo_available and not bun_available {
         console.print(
-            "  Neither cargo nor npm is available. Cannot install Tauri CLI automatically.",
+            "  Neither cargo nor bun is available. Cannot install Tauri CLI automatically.",
             style="muted"
         );
         console.print(
-            "  Please install Rust (for cargo) or Node.js (for npm) first.",
+            "  Please install Rust (for cargo) or Bun (https://bun.sh) first.",
             style="muted"
         );
         return;
@@ -1371,11 +1368,11 @@ def _check_and_install_tauri_cli -> None {
                 console.warning(f"  Error installing via cargo: {e}");
             }
         }
-        if npm_available {
-            console.print("  Installing Tauri CLI via npm...", style="muted");
+        if bun_available {
+            console.print("  Installing Tauri CLI via bun...", style="muted");
             try {
                 result = subprocess.run(
-                    ["npm", "install", "-g", "@tauri-apps/cli"],
+                    ["bun", "add", "-g", "@tauri-apps/cli"],
                     check=False,
                     timeout=300,
                     capture_output=False  # Show output
@@ -1384,18 +1381,18 @@ def _check_and_install_tauri_cli -> None {
                     console.print("  ✔ Tauri CLI installed", style="success");
                     return;
                 } else {
-                    console.warning("  Failed to install via npm");
+                    console.warning("  Failed to install via bun");
                 }
             } except Exception as e {
-                console.warning(f"  Error installing via npm: {e}");
+                console.warning(f"  Error installing via bun: {e}");
             }
         }
         console.print("  Please install manually:", style="muted");
         if cargo_available {
             console.print("    cargo install tauri-cli", style="muted");
         }
-        if npm_available {
-            console.print("    npm install -g @tauri-apps/cli", style="muted");
+        if bun_available {
+            console.print("    bun add -g @tauri-apps/cli", style="muted");
         }
     } else {
         console.print("  Skipping Tauri CLI installation.", style="muted");
@@ -1405,8 +1402,8 @@ def _check_and_install_tauri_cli -> None {
         if cargo_available {
             console.print("    cargo install tauri-cli", style="muted");
         }
-        if npm_available {
-            console.print("    npm install -g @tauri-apps/cli", style="muted");
+        if bun_available {
+            console.print("    bun add -g @tauri-apps/cli", style="muted");
         }
     }
 }
@@ -1846,22 +1843,22 @@ def _run_tauri_build(tauri_dir: Path, platform: Optional[str] = None) -> Path {
         target = "x86_64-unknown-linux-gnu";
     }
 
-    # Build command
-    build_cmd = ["npm", "run", "tauri", "build"];
+    # Build command - prefer cargo tauri build, fallback to bun if package.json has tauri scripts
+    build_cmd = ["cargo", "tauri", "build"];
     if target {
-        build_cmd.extend(["--", "--client", target]);
+        build_cmd.extend(["--target", target]);
     }
 
-    # Check if package.json has tauri scripts, if not, use cargo directly
+    # Check if package.json has tauri scripts, use bun run if so
     package_json = tauri_dir.parent / "package.json";
-    use_npm = False;
+    use_bun = False;
     if package_json.exists() {
         try {
             with open(package_json, "r") as f {
                 package_data = json.load(f);
                 scripts = package_data.get("scripts", {});
                 if "tauri" in scripts or "tauri:build" in scripts {
-                    use_npm = True;
+                    use_bun = True;
                 }
             }
         } except Exception {
@@ -1869,11 +1866,19 @@ def _run_tauri_build(tauri_dir: Path, platform: Optional[str] = None) -> Path {
         }
     }
 
-    if not use_npm {
-        # Use cargo tauri build directly
-        build_cmd = ["cargo", "tauri", "build"];
+    if use_bun {
+        # Ensure bun is available
+        import from jac_client.plugin.utils { ensure_bun_available }
+        if not ensure_bun_available() {
+            console.error(
+                "Bun is required for this project. Install manually: https://bun.sh"
+            );
+            raise RuntimeError("Bun is required") from None ;
+        }
+        # Use bun run tauri build
+        build_cmd = ["bun", "run", "tauri", "build"];
         if target {
-            build_cmd.extend(["--client", target]);
+            build_cmd.extend(["--", "--target", target]);
         }
     }
 
@@ -2210,32 +2215,40 @@ def _run_tauri_dev(tauri_dir: Path) -> subprocess.Popen {
     ) {
         console.warning("Tauri CLI not found.");
         console.print("  Install manually: cargo install tauri-cli", style="muted");
-        console.print("  Or use npm: npm install -D @tauri-apps/cli", style="muted");
+        console.print("  Or use bun: bun add -g @tauri-apps/cli", style="muted");
         raise RuntimeError(
             "Tauri CLI not installed. Install it first:\n"
             "  cargo install tauri-cli\n"
-            "  Or: npm install -D @tauri-apps/cli"
+            "  Or: bun add -g @tauri-apps/cli"
         ) ;
     }
 
     # Check if package.json has tauri scripts
     package_json = tauri_dir.parent / "package.json";
-    use_npm = False;
+    use_bun = False;
     if package_json.exists() {
         try {
             with open(package_json, "r") as f {
                 package_data = json.load(f);
                 scripts = package_data.get("scripts", {});
                 if "tauri" in scripts or "tauri:dev" in scripts {
-                    use_npm = True;
+                    use_bun = True;
                 }
             }
         } except Exception { }
     }
 
-    if use_npm {
-        # Use npm run tauri dev
-        dev_cmd = ["npm", "run", "tauri", "dev"];
+    if use_bun {
+        # Ensure bun is available
+        import from jac_client.plugin.utils { ensure_bun_available }
+        if not ensure_bun_available() {
+            console.error(
+                "Bun is required for this project. Install manually: https://bun.sh"
+            );
+            raise RuntimeError("Bun is required") from None ;
+        }
+        # Use bun run tauri dev
+        dev_cmd = ["bun", "run", "tauri", "dev"];
     } else {
         # Use cargo tauri dev directly
         dev_cmd = ["cargo", "tauri", "dev"];

jac_client/plugin/utils/__init__.jac

@@ -1 +1,4 @@
 """Utility modules for jac-client plugin."""
+
+import from .bun_installer { ensure_bun_available, prompt_install_bun }
+import from .client_deps { ensure_client_deps }

jac_client/plugin/utils/bun_installer.jac

@@ -0,0 +1,16 @@
+"""Bun installer utility for jac-client.
+
+Provides functions to check for Bun availability and prompt for installation.
+"""
+
+"""Check if bun is available, add to PATH if needed, or prompt to install.
+
+Returns True if bun is available (or was successfully installed), False otherwise.
+"""
+def ensure_bun_available -> bool;
+
+"""Prompt user to install Bun and install if confirmed.
+
+Returns True if installation succeeded, False otherwise.
+"""
+def prompt_install_bun -> bool;

jac_client/plugin/utils/client_deps.jac

@@ -0,0 +1,14 @@
+"""Client dependency checker utility for jac-client.
+
+Provides a function to check if required npm dependencies are configured
+and prompt the user to install defaults if missing.
+"""
+
+"""Check if client npm dependencies are configured, prompt to install if missing.
+
+Takes a JacClientConfig instance, checks if dependencies and devDependencies
+are both empty, and if so prompts the user to install default jac-client deps.
+
+Returns True if deps are configured (or were just installed), False if user declined.
+"""
+def ensure_client_deps(config_loader: object) -> bool;