jac-client 0.2.8__py3-none-any.whl → 0.2.11__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 (
@@ -78,6 +74,8 @@ impl ViteBundler.create_package_json(
     }
     # Generate tsconfig.json during build time
     self.create_tsconfig();
+    # Generate config files (postcss, tailwind, etc.) from jac.toml
+    self.create_config_files();
     return package_json_path;
 }
 
@@ -129,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();
@@ -152,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.
 """
@@ -301,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
@@ -330,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}],
@@ -375,6 +423,14 @@ impl ViteBundler.find_bundle(self: ViteBundler) -> Optional[Path] {
 
 """Run Vite build with generated config in .jac/client/configs/."""
 impl ViteBundler.build(self: ViteBundler, entry_file: Optional[Path] = None) -> None {
+    import sys;
+    import time;
+    import shutil;
+    import from jac_client.plugin.utils { ensure_bun_available }
+    # Ensure bun is available before proceeding
+    if not ensure_bun_available() {
+        raise ClientBundleError('Bun is required. Install manually: https://bun.sh') from None ;
+    }
     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() {
@@ -387,7 +443,7 @@ impl ViteBundler.build(self: ViteBundler, entry_file: Optional[Path] = None) ->
         build_dir = self._get_client_dir();
         node_modules = build_dir / '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() {
@@ -395,65 +451,78 @@ impl ViteBundler.build(self: ViteBundler, entry_file: Optional[Path] = None) ->
                 shutil.copy2(configs_package_json, build_package_json);
             }
             try {
-                # Install to .jac/client/node_modules
-                subprocess.run(
-                    ['npm', 'install'],
-                    cwd=build_dir,
-                    check=True,
-                    capture_output=True,
-                    text=True
+                # Install to .jac/client/node_modules with progress feedback
+                print("\n  ⏳ Installing dependencies...\n", flush=True);
+                start_time = time.time();
+                result = subprocess.run(
+                    ['bun', 'install'], cwd=build_dir, check=False, text=True
                 );
-            } except subprocess.CalledProcessError as e {
-                raise e from ClientBundleError(
-                    f"Failed to install npm dependencies: {e.stderr}"
-                ) ;
+                elapsed = time.time() - start_time;
+                if result.returncode != 0 {
+                    print(
+                        f"\n  ✖ bun install failed after {elapsed:.1f}s",
+                        file=sys.stderr
+                    );
+                    raise ClientBundleError("Failed to install dependencies") ;
+                }
+                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
-        result = subprocess.run(
-            command, cwd=build_dir, check=False, capture_output=True, text=True
-        );
+        print("\n  ⏳ Building client bundle...\n", flush=True);
+        start_time = time.time();
+        result = subprocess.run(command, cwd=build_dir, check=False, text=True);
+        elapsed = time.time() - start_time;
         if result.returncode != 0 {
-            error_msg = result.stderr or result.stdout or 'Unknown error';
+            print(f"\n  ✖ Vite build failed after {elapsed:.1f}s", file=sys.stderr);
             raise ClientBundleError(
-                f"Vite build failed:\n{error_msg}\nCommand: {' '.join(command)}"
+                f"Vite build failed (see output above)\nCommand: {' '.join(command)}"
             ) from None ;
         }
+        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);
         }
     }
 }
@@ -521,6 +590,9 @@ export default defineConfig({{
   plugins: [react()],
   root: buildDir,
   publicDir: false,
+  build: {{
+    sourcemap: true, // Enable source maps for better error messages
+  }},
   server: {{
     watch: {{
       usePolling: true,
@@ -547,7 +619,7 @@ export default defineConfig({{
   }},
   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}],
@@ -558,8 +630,61 @@ export default defineConfig({{
     return config_path;
 }
 
+"""Create config files from jac.toml [plugins.client.configs].
+
+Generates JavaScript config files (e.g., postcss.config.js, tailwind.config.js)
+from TOML configuration. Each key in [plugins.client.configs] becomes a config file.
+
+Example jac.toml:
+    [plugins.client.configs.postcss]
+    plugins = ["tailwindcss", "autoprefixer"]
+
+    [plugins.client.configs.tailwind]
+    content = ["./src/**/*.{js,jsx}"]
+
+This generates:
+    - .jac/client/configs/postcss.config.js
+    - .jac/client/configs/tailwind.config.js
+"""
+impl ViteBundler.create_config_files(self: ViteBundler) -> list[Path] {
+    configs = self.config_loader.get_configs();
+    if not configs {
+        return [];
+    }
+    build_dir = self._get_client_dir();
+    configs_dir = build_dir / 'configs';
+    configs_dir.mkdir(parents=True, exist_ok=True);
+    created_files: list[Path] = [];
+    for (config_name, config_data) in configs.items() {
+        config_path = configs_dir / f'{config_name}.config.js';
+
+        # Convert the TOML config to JavaScript module.exports
+        js_content = _toml_config_to_js(config_name, config_data);
+        config_path.write_text(js_content, encoding='utf-8');
+        created_files.append(config_path);
+    }
+    return created_files;
+}
+
+"""Convert TOML config data to JavaScript config file content.
+
+Generates a generic module.exports with the config data as JSON.
+"""
+def _toml_config_to_js(config_name: str, config_data: dict) -> str {
+    return f"module.exports = {json.dumps(config_data, indent=2)};\n";
+}
+
 """Start Vite dev server as a subprocess."""
 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)
@@ -584,23 +709,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("[Vite] Installing dependencies...");
-            subprocess.run(
-                ['npm', 'install'],
-                cwd=build_dir,
-                check=True,
-                capture_output=True,
-                text=True
+            print("\n  ⏳ Installing dependencies...\n", flush=True);
+            start_time = time.time();
+            result = subprocess.run(
+                ['bun', 'install'], cwd=build_dir, check=False, text=True
             );
-        } except subprocess.CalledProcessError as e {
-            print(f"[Vite] Error installing dependencies: {e.stderr}");
-            raise ;
+            elapsed = time.time() - start_time;
+            if result.returncode != 0 {
+                print(
+                    f"\n  ✖ bun install failed after {elapsed:.1f}s", file=sys.stderr
+                );
+                raise ClientBundleError("Failed to install dependencies") ;
+            }
+            print(f"\n  ✔ Dependencies installed ({elapsed:.1f}s)", flush=True);
         } finally {
             # Clean up temp package.json
             if build_package_json.exists() {
@@ -616,10 +743,10 @@ impl ViteBundler.start_dev_server(self: ViteBundler, port: int = 3000) -> Any {
         ) ;
     }
     config_rel = dev_config.relative_to(build_dir);
-    print(f"[Vite] Starting dev server on port {port}...");
+    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/desktop/sidecar/main.py

@@ -0,0 +1,144 @@
+#!/usr/bin/env python3
+"""
+Jac Sidecar Entry Point
+
+This is the entry point for the Jac backend sidecar.
+It launches the Jac runtime and starts an HTTP API server.
+
+Usage:
+    python -m jac_client.plugin.src.targets.desktop.sidecar.main [OPTIONS]
+    # Or via wrapper script: ./jac-sidecar.sh [OPTIONS]
+
+Options:
+    --module-path PATH    Path to the .jac module file (default: main.jac)
+    --port PORT          Port to bind the API server (default: 8000)
+    --base-path PATH     Base path for the project (default: current directory)
+    --host HOST          Host to bind to (default: 127.0.0.1)
+    --help               Show this help message
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+from jaclang.cli.console import console
+
+
+def main():
+    """Main entry point for the sidecar."""
+    parser = argparse.ArgumentParser(
+        description="Jac Backend Sidecar - Runs Jac API server in a bundled executable"
+    )
+    parser.add_argument(
+        "--module-path",
+        type=str,
+        default="main.jac",
+        help="Path to the .jac module file (default: main.jac)",
+    )
+    parser.add_argument(
+        "--port",
+        type=int,
+        default=8000,
+        help="Port to bind the API server (default: 8000)",
+    )
+    parser.add_argument(
+        "--base-path",
+        type=str,
+        default=None,
+        help="Base path for the project (default: current directory)",
+    )
+    parser.add_argument(
+        "--host",
+        type=str,
+        default="127.0.0.1",
+        help="Host to bind to (default: 127.0.0.1)",
+    )
+
+    args = parser.parse_args()
+
+    # Determine base path
+    if args.base_path:
+        base_path = Path(args.base_path).resolve()
+    else:
+        # Try to find project root (look for jac.toml)
+        base_path = Path.cwd()
+        for parent in [base_path] + list(base_path.parents):
+            if (parent / "jac.toml").exists():
+                base_path = parent
+                break
+
+    # Resolve module path
+    module_path = Path(args.module_path)
+    if not module_path.is_absolute():
+        module_path = base_path / module_path
+
+    if not module_path.exists():
+        console.print(f"Error: Module file not found: {module_path}", file=sys.stderr)
+        console.print(f"  Base path: {base_path}", file=sys.stderr)
+        sys.exit(1)
+
+    # Extract module name (without .jac extension)
+    module_name = module_path.stem
+    module_base = module_path.parent
+
+    # Import Jac runtime and server
+    try:
+        # Import jaclang (must be installed via pip)
+        from jaclang.pycore.runtime import JacRuntime as Jac
+    except ImportError as e:
+        console.print(f"Error: Failed to import Jac runtime: {e}", file=sys.stderr)
+        console.print(
+            "  Make sure jaclang is installed: pip install jaclang", file=sys.stderr
+        )
+        sys.exit(1)
+
+    # Initialize Jac runtime
+    try:
+        # Import the module
+        Jac.jac_import(target=module_name, base_path=str(module_base), lng="jac")
+        if Jac.program.errors_had:
+            console.print("Error: Failed to compile module:", file=sys.stderr)
+            for error in Jac.program.errors_had:
+                console.print(f"  {error}", file=sys.stderr)
+            sys.exit(1)
+    except Exception as e:
+        console.print(
+            f"Error: Failed to load module '{module_name}': {e}", file=sys.stderr
+        )
+        import traceback
+
+        traceback.print_exc()
+        sys.exit(1)
+
+    # Create and start the API server
+    try:
+        # Get server class (allows plugins like jac-scale to provide enhanced server)
+        server_class = Jac.get_api_server_class()
+        server = server_class(
+            module_name=module_name, port=args.port, base_path=str(base_path)
+        )
+
+        console.print("Jac Sidecar starting...")
+        console.print(f"  Module: {module_name}")
+        console.print(f"  Base path: {base_path}")
+        console.print(f"  Server: http://{args.host}:{args.port}")
+        console.print("\nPress Ctrl+C to stop the server\n")
+
+        # Start the server (blocks until interrupted)
+        server.start(dev=False)
+
+    except KeyboardInterrupt:
+        console.print("\nShutting down sidecar...")
+        sys.exit(0)
+    except Exception as e:
+        console.print(f"Error: Server failed to start: {e}", file=sys.stderr)
+        import traceback
+
+        traceback.print_exc()
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

jac_client/plugin/src/targets/desktop_target.jac

@@ -0,0 +1,37 @@
+"""Desktop target implementation.
+
+This target will be implemented in Phase 2.
+"""
+import from pathlib { Path }
+import from typing { Optional }
+import from jac_client.plugin.src.targets.registry { ClientTarget }
+
+"""Desktop build target (placeholder for Phase 2)."""
+class DesktopTarget(ClientTarget) {
+    def init(self: DesktopTarget) {
+        self.name = "desktop";
+        self.default = False;
+        self.requires_setup = True;
+        self.config_section = "desktop";
+        self.output_dir = Path("src-tauri/target/release/bundle");
+    }
+
+    """Setup desktop target - scaffold Tauri project structure."""
+    override def setup(self: DesktopTarget, project_dir: Path) -> None;
+
+    """Build desktop app - build web bundle first, then wrap with Tauri."""
+    override def build(
+        self: DesktopTarget,
+        entry_file: Path,
+        project_dir: Path,
+        platform: Optional[str] = None
+    ) -> Path;
+
+    """Start desktop dev server - start web dev server and launch tauri dev."""
+    override def dev(self: DesktopTarget, entry_file: Path, project_dir: Path) -> None;
+
+    """Start desktop app - build web bundle and launch Tauri with built bundle."""
+    override def start(
+        self: DesktopTarget, entry_file: Path, project_dir: Path
+    ) -> None;
+}