@ape-egg/vibe-compiler 3.0.0

package/README.md

@@ -0,0 +1,19 @@
+# @ape-egg/vibe-compiler
+
+The optional Rust compiler for [Vibe](https://www.npmjs.com/package/@ape-egg/vibe). The runtime never needs it — this package exists for when you want pre-rendered initial paint (hyperspeed manifests), build-time component inlining, iteration batch functions, custom-element transforms, or compiled SPA output.
+
+```bash
+bun add -d @ape-egg/vibe-compiler   # or npm i -D
+bunx vibe --init                    # write the vibe-compiler config into package.json
+bunx vibe                           # compile
+```
+
+Compiled output is, by invariant, still runtime Vibe code — compiling is an optimization, never a requirement.
+
+## Platform support
+
+Prebuilt binaries ship for **macOS arm64** and **Linux x64**. On any other platform the bin shim falls back to `cargo run` — you need a Rust toolchain, and the first compile builds from source (minutes, once). There is no Windows binary yet.
+
+## Configuration
+
+Lives in your project's `package.json` under `"vibe-compiler"`. See the [Vibe compiler docs](https://vibe.korte.kim/compiler/introduction.html) for every option and flag (`--minify`, `--watch`, `--spa`, `--source`, `--output`, and the `*-as-is` opt-outs).

package/bin/vibe-compile.js

@@ -0,0 +1,121 @@
+#!/usr/bin/env node
+
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import { existsSync } from 'node:fs';
+import { platform, arch } from 'node:os';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const nativeDir = join(__dirname, '..', 'native');
+const originalCwd = process.cwd();
+
+// Map Node.js platform/arch to binary names
+const getPlatformBinary = () => {
+  const os = platform();
+  const cpu = arch();
+
+  const platformMap = {
+    'darwin-arm64': 'vibe-compiler-darwin-arm64',
+    'darwin-x64': 'vibe-compiler-darwin-x64',
+    'linux-x64': 'vibe-compiler-linux-x64',
+    'linux-arm64': 'vibe-compiler-linux-arm64',
+    'win32-x64': 'vibe-compiler-win32-x64.exe',
+  };
+
+  const key = `${os}-${cpu}`;
+  const binary = platformMap[key];
+
+  if (!binary) {
+    console.error(`Unsupported platform: ${os}-${cpu}`);
+    console.error('Supported platforms: darwin-arm64, darwin-x64, linux-x64, linux-arm64, win32-x64');
+    process.exit(1);
+  }
+
+  return binary;
+};
+
+// The wrapper is what gets killed (Ctrl+C, a dev server's child.kill(), a
+// process manager) — without forwarding, the compiler child survives as an
+// orphan whose watch lock blocks every future `--watch` on the same output.
+const wireLifecycle = (child) => {
+  ['SIGINT', 'SIGTERM', 'SIGHUP'].forEach((signal) =>
+    process.on(signal, () => child.kill(signal)),
+  );
+  process.on('exit', () => child.kill());
+};
+
+const run = () => {
+  const binary = getPlatformBinary();
+  const binaryPath = join(nativeDir, binary);
+  let userArgs = process.argv.slice(2);
+
+  // Handle subcommand: vibe compile [args]
+  // If first arg is "compile" or "c", remove it (the binary doesn't need it)
+  if (userArgs[0] === 'compile' || userArgs[0] === 'c') {
+    userArgs = userArgs.slice(1);
+  } else if (userArgs[0] && !userArgs[0].startsWith('-')) {
+    // Unknown subcommand
+    console.error(`Unknown subcommand: ${userArgs[0]}`);
+    console.error('Available subcommands: compile (or c)');
+    console.error('Usage: vibe compile [options]');
+    process.exit(1);
+  }
+  // If no subcommand provided, default to compile behavior (pass args as-is)
+
+  // Check if native binary exists
+  if (!existsSync(binaryPath)) {
+    // Fall back to cargo run for development
+    console.info('[vibe-compile] Native binary not found, building with cargo...');
+
+    const srcDir = join(__dirname, '..', 'src');
+
+    if (!existsSync(join(srcDir, 'Cargo.toml'))) {
+      console.error('Neither native binary nor Rust source found.');
+      console.error(`Expected binary at: ${binaryPath}`);
+      console.error(`Or Cargo.toml at: ${srcDir}`);
+      process.exit(1);
+    }
+
+    // Pass --cwd to tell the Rust binary the original working directory
+    const cargoArgs = ['run', '--release', '--', '--cwd', originalCwd, ...userArgs];
+
+    const cargo = spawn('cargo', cargoArgs, {
+      cwd: srcDir,
+      stdio: 'inherit',
+    });
+    wireLifecycle(cargo);
+
+    cargo.on('error', (err) => {
+      if (err.code === 'ENOENT') {
+        console.error('Cargo not found. Please install Rust: https://rustup.rs');
+      } else {
+        console.error('Failed to run cargo:', err.message);
+      }
+      process.exit(1);
+    });
+
+    cargo.on('close', (code) => {
+      process.exit(code ?? 0);
+    });
+
+    return;
+  }
+
+  // Run the native binary (it runs in the user's cwd, so no --cwd needed)
+  const child = spawn(binaryPath, userArgs, {
+    stdio: 'inherit',
+  });
+  wireLifecycle(child);
+
+  child.on('error', (err) => {
+    console.error('Failed to run vibe-compiler:', err.message);
+    process.exit(1);
+  });
+
+  child.on('close', (code) => {
+    process.exit(code ?? 0);
+  });
+};
+
+run();

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@ape-egg/vibe-compiler",
+  "version": "3.0.0",
+  "type": "module",
+  "description": "Optional Rust compiler for Vibe — pre-renders, inlines components, and optimizes iterations. The runtime never needs it.",
+  "homepage": "https://vibe.korte.kim",
+  "bin": {
+    "vibe": "./bin/vibe-compile.js"
+  },
+  "files": [
+    "bin",
+    "native",
+    "src/Cargo.toml",
+    "src/Cargo.lock",
+    "src/main.rs",
+    "src/config.rs",
+    "src/compiler",
+    "src/parser"
+  ],
+  "keywords": [
+    "vibe",
+    "compiler",
+    "reactive",
+    "framework",
+    "prerender"
+  ],
+  "author": "kkortes",
+  "license": "ISC",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {}
+}