rails_vite 0.1.0.beta1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ddf9204a38a0fd3b2a771325dbdb49f94367b8e8e9577851a6346850c7efd499
+  data.tar.gz: 941bcd3a4321475a02a3ea735cd41a0e451cd71317c6fbd8a95daee1af011b8e
+SHA512:
+  metadata.gz: ec476f3602aeaab095dd8cfe2153944a382bd22ee12dec1fcbacc5b3dc0ccac8473c0c6ad24130431bb10a73c658a78e41795c69313809067ceabf02aa340770
+  data.tar.gz: f45dcd623a42524e171b98e87d3fca04b9f49b5a76435ffe8a5d56b0c1bf1f07feb84d71a709485e1f17e33bab2ca77d9c4a34c0d35344554176ec220a316b78

data/CHANGELOG.md

@@ -0,0 +1,22 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog],
+and this project adheres to [Semantic Versioning].
+
+## [Unreleased]
+
+## [0.1.0] - 2026-03-07
+
+### Added
+
+- Initial release ([@skryukov])
+
+[@skryukov]: https://github.com/skryukov
+
+[Unreleased]: https://github.com/skryukov/rails_vite/compare/v0.1.0...HEAD
+[0.1.0]: https://github.com/skryukov/rails_vite/commits/v0.1.0
+
+[Keep a Changelog]: https://keepachangelog.com/en/1.0.0/
+[Semantic Versioning]: https://semver.org/spec/v2.0.0.html

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Svyatoslav Kryukov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,271 @@
+# RailsVite
+
+Vite integration for Rails, inspired by [Laravel's Vite plugin](https://laravel.com/docs/12.x/vite). No proxy, no config duplication, no magic.
+
+## How It Works
+
+**Development:** The Vite plugin writes `tmp/rails-vite.json` with the dev server URL. The Rails helper reads it and emits `<script>` tags pointing directly at Vite. The browser talks to Vite — Puma never touches your assets.
+
+**Production:** `vite build` outputs fingerprinted assets to `public/vite/` with a standard Vite manifest. The Rails helper reads the manifest and emits the correct tags.
+
+No Rack proxy. No `config/vite.json`. No version-locked packages.
+
+## Quick Start
+
+Add to your Gemfile:
+
+```ruby
+gem "rails_vite"
+```
+
+Run the install generator:
+
+```bash
+bundle install
+bin/rails generate rails_vite:install
+```
+
+This creates `vite.config.ts`, installs dependencies, and updates your layout.
+
+Start development:
+
+```bash
+bin/dev
+```
+
+## Usage
+
+In your layout:
+
+```erb
+<%= vite_tags "application.js" %>
+```
+
+Short names are automatically prefixed with `sourceDir` (default: `app/javascript`). Paths containing `/` are used as-is.
+
+**Development output** (when `tmp/rails-vite.json` exists):
+
+```html
+<script src="http://localhost:5173/@vite/client" type="module"></script>
+<script src="http://localhost:5173/app/javascript/application.js" type="module"></script>
+```
+
+**Production output** (reads manifest):
+
+```html
+<link rel="modulepreload" href="/vite/assets/vendor-b3c4d5e6.js" />
+<script src="/vite/assets/application-a1b2c3d4.js" type="module"></script>
+<link rel="stylesheet" href="/vite/assets/application-x9y8z7w6.css" />
+```
+
+### Helpers
+
+| Helper | Purpose |
+|--------|---------|
+| `vite_tags(*entries, nonce: nil)` | Emits script, stylesheet, and modulepreload tags |
+| `vite_asset_path(name)` | Returns the fingerprinted path from the manifest |
+| `vite_image_tag(name, **options)` | Image tag with manifest-resolved src |
+
+### CSS Entry Points
+
+CSS files are detected by extension and emit `<link rel="stylesheet">`:
+
+```erb
+<%= vite_tags "application.css" %>
+```
+
+### CSP Nonces
+
+```erb
+<%= vite_tags "application.js", nonce: content_security_policy_nonce %>
+```
+
+### Asset Discovery (Images, Fonts)
+
+Use `import.meta.glob` in your entry point to include assets in the Vite manifest:
+
+```js
+// app/javascript/application.js
+import.meta.glob(['../assets/images/**']);
+```
+
+Then reference them in views:
+
+```erb
+<%= vite_image_tag "app/assets/images/logo.png", alt: "Logo" %>
+```
+
+## Vite Config
+
+The install generator creates a minimal `vite.config.ts`:
+
+```typescript
+import { defineConfig } from 'vite';
+import rails from 'rails-vite-plugin';
+
+export default defineConfig({
+  plugins: [
+    rails(),
+  ],
+});
+```
+
+### Plugin Options
+
+| Option | Default | Description |
+|--------|---------|-------------|
+| `input` | auto-detected | Entry point(s). Auto-detects `application.{js,ts,jsx,tsx}` in `sourceDir` |
+| `sourceDir` | `'app/javascript'` | Source directory. Short names are prefixed with this. Also sets the `@` import alias |
+| `ssr` | — | SSR entry point |
+| `ssrOutputDirectory` | `'ssr'` | SSR output directory |
+| `devMetaFile` | `'tmp/rails-vite.json'` | Dev metadata file path |
+| `buildDirectory` | `'vite'` | Build output subdirectory inside `public/` |
+| `publicDirectory` | `'public'` | Public directory |
+| `refresh` | `true` | Paths to watch for full-page reload. `true` watches `app/views/**` and `app/helpers/**` |
+
+### Multiple Entry Points
+
+```typescript
+rails({
+  input: ['application.js', 'admin.js'],
+})
+```
+
+```erb
+<!-- In application layout -->
+<%= vite_tags "application.js" %>
+
+<!-- In admin layout -->
+<%= vite_tags "admin.js" %>
+```
+
+### Custom Source Directory
+
+```typescript
+rails({
+  input: ['entrypoints/application.ts', 'entrypoints/admin.ts'],
+  sourceDir: 'app/frontend',
+})
+```
+
+```erb
+<%= vite_tags "entrypoints/application.ts" %>
+```
+
+## Adding Frameworks
+
+### React
+
+```bash
+npm install -D @vitejs/plugin-react
+```
+
+```typescript
+import { defineConfig } from 'vite';
+import rails from 'rails-vite-plugin';
+import react from '@vitejs/plugin-react';
+
+export default defineConfig({
+  plugins: [
+    react(),
+    rails(),
+  ],
+});
+```
+
+The React Refresh preamble is injected automatically when `@vitejs/plugin-react` is detected — no manual setup needed.
+
+### Vue
+
+```bash
+npm install -D @vitejs/plugin-vue
+```
+
+```typescript
+import { defineConfig } from 'vite';
+import rails from 'rails-vite-plugin';
+import vue from '@vitejs/plugin-vue';
+
+export default defineConfig({
+  plugins: [
+    vue(),
+    rails(),
+  ],
+});
+```
+
+## SSR
+
+Set `ssr` to the entry point used for server-side rendering. When you run `npx vite build --ssr`, the plugin uses this as the input and outputs to the `ssrOutputDirectory` (default: `ssr/`).
+
+```typescript
+rails({
+  ssr: 'ssr.tsx',
+})
+```
+
+Build and run:
+
+```bash
+npx vite build && npx vite build --ssr
+node ssr/ssr.js
+```
+
+## Auto Build
+
+When the Vite dev server is not running, rails_vite automatically rebuilds assets on the first request if sources have changed. This is useful for system tests and quick checks without running `bin/dev`.
+
+Disable it:
+
+```ruby
+# config/initializers/rails_vite.rb
+Rails.application.config.rails_vite.auto_build = false
+```
+
+By default, auto build is enabled in development and test (`Rails.env.local?`).
+
+Note: for parallel test runners, disable auto build and use `rake vite:build` before the suite instead.
+
+## Testing the Build
+
+To verify your production build works in development:
+
+```bash
+rake vite:build         # build assets
+bin/rails s             # start Rails without Vite dev server
+```
+
+Without the Vite dev server running (no `tmp/rails-vite.json`), Rails serves built assets from `public/vite/`. To switch back to dev mode, start Vite again — the dev metadata takes priority.
+
+Clean up built assets with `rake vite:clobber`.
+
+## Custom Paths
+
+If you override `build.outDir` in `vite.config.ts`, tell the gem where to find things:
+
+```ruby
+# config/initializers/rails_vite.rb
+Rails.application.config.rails_vite.manifest_path = Rails.root.join("public/custom/manifest.json")
+Rails.application.config.rails_vite.asset_prefix = "/custom"
+```
+
+Defaults match the plugin defaults — no config needed if you follow conventions.
+
+## Rake Tasks
+
+| Task | Description |
+|------|-------------|
+| `rake vite:build` | Build assets for production |
+| `rake vite:install` | Install JavaScript dependencies |
+| `rake vite:clobber` | Remove `public/vite/` |
+
+`vite:build` hooks into `assets:precompile` and `test:prepare` automatically. Skip with `SKIP_VITE_BUILD=1`.
+
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/skryukov/rails_vite.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/generators/rails_vite/install/install_generator.rb

@@ -0,0 +1,75 @@
+require "rails/generators"
+
+module RailsVite
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path("templates", __dir__)
+
+      def install_dependencies
+        say "Installing Vite and rails-vite-plugin..."
+        run RailsVite::Tasks.add_command("vite", "rails-vite-plugin")
+      end
+
+      def create_vite_config
+        template "vite.config.ts.tt", "vite.config.ts"
+      end
+
+      def create_entrypoint
+        unless File.exist?("app/javascript/application.js")
+          create_file "app/javascript/application.js", "// Entry point for Vite\n"
+        end
+      end
+
+      def update_gitignore
+        return if File.read(".gitignore").include?("public/vite")
+
+        append_to_file ".gitignore", <<~GITIGNORE
+
+          # Vite
+          /public/vite
+        GITIGNORE
+      end
+
+      def update_layout
+        layout_path = "app/views/layouts/application.html.erb"
+        return unless File.exist?(layout_path)
+
+        gsub_file layout_path,
+          /<%=\s*javascript_include_tag\s+["']application["'].*%>/,
+          '<%= vite_tags "application" %>'
+
+        gsub_file layout_path,
+          /<%=\s*stylesheet_link_tag\s+["']application["'].*%>/,
+          '<%= vite_tags "application.css" %>'
+      end
+
+      def setup_procfile
+        if File.exist?("Procfile.dev")
+          unless File.read("Procfile.dev").include?("vite")
+            append_to_file "Procfile.dev", "js: #{vite_dev_command}\n"
+          end
+        else
+          template "Procfile.dev.tt", "Procfile.dev"
+        end
+      end
+
+      def setup_bin_dev
+        return if File.exist?("bin/dev")
+
+        copy_file "bin/dev", "bin/dev"
+        chmod "bin/dev", 0o755
+      end
+
+      def done
+        say ""
+        say "Vite installed! Run `bin/dev` to start development.", :green
+      end
+
+      private
+
+      def vite_dev_command
+        RailsVite::Tasks.dev_command
+      end
+    end
+  end
+end

data/lib/generators/rails_vite/install/templates/Procfile.dev.tt

@@ -0,0 +1,2 @@
+web: bin/rails server
+js: <%= vite_dev_command %>

data/lib/generators/rails_vite/install/templates/bin/dev

@@ -0,0 +1,23 @@
+#!/usr/bin/env sh
+
+export PORT="${PORT:-3000}"
+
+if command -v overmind 1> /dev/null 2>&1
+then
+  overmind start -f Procfile.dev "$@"
+  exit $?
+fi
+
+if command -v hivemind 1> /dev/null 2>&1
+then
+  echo "Hivemind is installed. Running the application with Hivemind..."
+  exec hivemind Procfile.dev "$@"
+  exit $?
+fi
+
+if gem list --no-installed --exact --silent foreman; then
+  echo "Installing foreman..."
+  gem install foreman
+fi
+
+foreman start -f Procfile.dev "$@"

data/lib/generators/rails_vite/install/templates/vite.config.ts.tt

@@ -0,0 +1,8 @@
+import { defineConfig } from 'vite';
+import rails from 'rails-vite-plugin';
+
+export default defineConfig({
+  plugins: [
+    rails(),
+  ],
+});

data/lib/rails_vite/auto_build.rb

@@ -0,0 +1,65 @@
+require "find"
+
+module RailsVite
+  class AutoBuild
+    NEVER = Time.at(0).freeze
+    SOURCE_CHECK_INTERVAL = 2 # seconds
+
+    def initialize(app, config)
+      @app = app
+      @config = config
+      @mutex = Mutex.new
+      @last_build_at = NEVER
+      @cached_source_mtime = nil
+      @source_mtime_checked_at = nil
+    end
+
+    def call(env)
+      build! if stale?
+      @app.call(env)
+    end
+
+    private
+
+    def build!
+      @mutex.synchronize do
+        return unless stale?
+
+        Rails.logger.error("rails-vite: build failed") unless system(RailsVite::Tasks.build_command)
+        @last_build_at = Time.now
+        @cached_source_mtime = nil
+        @source_mtime_checked_at = nil
+      end
+    end
+
+    def stale?
+      !File.exist?(@config.manifest_path) ||
+        latest_source_mtime > @last_build_at
+    end
+
+    def latest_source_mtime
+      now = Time.now
+      if @cached_source_mtime && @source_mtime_checked_at && (now - @source_mtime_checked_at) < SOURCE_CHECK_INTERVAL
+        return @cached_source_mtime
+      end
+
+      @source_mtime_checked_at = now
+      @cached_source_mtime = compute_latest_source_mtime
+    end
+
+    def compute_latest_source_mtime
+      latest = NEVER
+      source_path = Rails.root.join(@config.source_dir).to_s
+
+      Find.find(source_path) do |path|
+        next unless File.file?(path)
+        mtime = File.mtime(path)
+        latest = mtime if mtime > latest
+      end
+
+      latest
+    rescue Errno::ENOENT
+      Time.now # source dir missing — trigger build to surface the error
+    end
+  end
+end

data/lib/rails_vite/config.rb

@@ -0,0 +1,61 @@
+module RailsVite
+  class Config
+    META_FILENAME = "rails-vite.json"
+
+    attr_writer :dev_meta_path, :manifest_path, :asset_prefix, :auto_build
+
+    def dev_meta_path
+      @dev_meta_path || Rails.root.join("tmp", META_FILENAME)
+    end
+
+    def manifest_path
+      @manifest_path || Rails.root.join("public/vite/manifest.json")
+    end
+
+    def asset_prefix
+      @asset_prefix || "/vite"
+    end
+
+    def source_dir
+      plugin_meta["sourceDir"] || "app/javascript"
+    end
+
+    def auto_build?
+      return @auto_build if defined?(@auto_build)
+      Rails.env.local?
+    end
+
+    def dev_server_running?
+      !!dev_server_url
+    end
+
+    def dev_server_url
+      plugin_meta["url"]
+    end
+
+    def react_refresh?
+      plugin_meta["reactRefresh"] == true
+    end
+
+    private
+
+    def plugin_meta
+      if Rails.env.local?
+        load_plugin_meta
+      else
+        @plugin_meta ||= load_plugin_meta
+      end
+    end
+
+    def load_plugin_meta
+      JSON.parse(dev_meta_path.read)
+    rescue Errno::ENOENT
+      build_meta_path = manifest_path.dirname.join(META_FILENAME)
+      begin
+        JSON.parse(build_meta_path.read)
+      rescue Errno::ENOENT, JSON::ParserError
+        {}
+      end
+    end
+  end
+end

data/lib/rails_vite/engine.rb

@@ -0,0 +1,20 @@
+module RailsVite
+  class Engine < ::Rails::Engine
+    initializer "rails_vite.config", before: :load_config_initializers do |app|
+      app.config.rails_vite = RailsVite.config
+    end
+
+    initializer "rails_vite.auto_build", after: :load_config_initializers do |app|
+      vite_config = RailsVite.config
+      if vite_config.auto_build? && !vite_config.dev_server_running?
+        app.middleware.use RailsVite::AutoBuild, vite_config
+      end
+    end
+
+    initializer "rails_vite.helpers" do
+      ActiveSupport.on_load(:action_view) do
+        include RailsVite::TagHelper
+      end
+    end
+  end
+end

data/lib/rails_vite/errors.rb

@@ -0,0 +1,20 @@
+module RailsVite
+  class Error < StandardError; end
+
+  class MissingManifestError < Error
+    def initialize(path)
+      message = if Rails.env.local?
+        "Vite manifest not found at #{path}. Start the Vite dev server with `bin/dev` or precompile assets with `rake vite:build`."
+      else
+        "Vite manifest not found at #{path}. Run `rake vite:build` to compile assets."
+      end
+      super(message)
+    end
+  end
+
+  class MissingEntryError < Error
+    def initialize(name, path)
+      super("Entry \"#{name}\" not found in Vite manifest at #{path}.")
+    end
+  end
+end

data/lib/rails_vite/manifest.rb

@@ -0,0 +1,58 @@
+module RailsVite
+  class Manifest
+    NO_MANIFEST_DIGEST = "no-manifest"
+
+    def initialize(path)
+      @path = path
+    end
+
+    def lookup(name)
+      manifest = data
+      entry = manifest[name] || raise(MissingEntryError.new(name, @path))
+
+      {
+        file: entry["file"],
+        css: entry.fetch("css", []),
+        imports: resolve_imports(entry, Set.new, manifest)
+      }
+    end
+
+    def path_for(name)
+      lookup(name)[:file]
+    end
+
+    def digest
+      Digest::MD5.file(@path).hexdigest
+    rescue Errno::ENOENT
+      NO_MANIFEST_DIGEST
+    end
+
+    private
+
+    def data
+      if Rails.env.local?
+        load_manifest
+      else
+        @data ||= load_manifest
+      end
+    end
+
+    def load_manifest
+      JSON.parse(File.read(@path))
+    rescue Errno::ENOENT
+      raise MissingManifestError.new(@path)
+    end
+
+    def resolve_imports(entry, seen, manifest)
+      entry.fetch("imports", []).flat_map do |import_key|
+        next [] if seen.include?(import_key)
+        seen.add(import_key)
+
+        imported = manifest[import_key]
+        next [] unless imported
+
+        [imported["file"]] + resolve_imports(imported, seen, manifest)
+      end
+    end
+  end
+end

data/lib/rails_vite/tag_helper.rb

@@ -0,0 +1,114 @@
+module RailsVite
+  module TagHelper
+    CSS_EXTENSIONS = /\.(?:css|scss|sass|less|styl|pcss)\z/
+
+    def vite_tags(*entries, nonce: nil, **options)
+      config = RailsVite.config
+      resolved = entries.map { |e| resolve_vite_entry(e, config.source_dir) }
+
+      if config.dev_server_running?
+        vite_dev_tags(resolved, config.dev_server_url, nonce: nonce)
+      else
+        vite_prod_tags(resolved, nonce: nonce)
+      end
+    end
+
+    def vite_asset_path(name)
+      vite_asset_url(RailsVite.manifest.path_for(name))
+    end
+
+    def vite_image_tag(name, **options)
+      image_tag(vite_asset_path(name), **options)
+    end
+
+    private
+
+    def vite_dev_tags(entries, dev_url, nonce: nil)
+      tags = []
+
+      unless @_vite_client_emitted
+        if RailsVite.config.react_refresh?
+          tags << tag.script(type: "module", nonce: nonce) {
+            <<~JS.squish.html_safe
+              import{injectIntoGlobalHook}from'#{dev_url}/@react-refresh';
+              injectIntoGlobalHook(window);
+              window.$RefreshReg$=()=>{};
+              window.$RefreshSig$=()=>(type)=>type;
+            JS
+          }
+        end
+        tags << tag.script(src: "#{dev_url}/@vite/client", type: "module", nonce: nonce)
+        @_vite_client_emitted = true
+      end
+
+      entries.each do |entry|
+        tags << build_asset_tag(entry, "#{dev_url}/#{entry}", nonce: nonce)
+      end
+
+      safe_join(tags, "\n")
+    end
+
+    def vite_prod_tags(entries, nonce: nil)
+      tags = []
+      preloaded = Set.new
+
+      entries.each do |entry|
+        result = RailsVite.manifest.lookup(entry)
+
+        Array(result[:imports]).each do |import_file|
+          next if preloaded.include?(import_file)
+          preloaded.add(import_file)
+          tags << tag.link(rel: "modulepreload", href: vite_asset_url(import_file), nonce: nonce)
+        end
+
+        tags << build_asset_tag(entry, vite_asset_url(result[:file]), nonce: nonce)
+
+        Array(result[:css]).each do |css_file|
+          tags << tag.link(rel: "stylesheet", href: vite_asset_url(css_file), nonce: nonce)
+        end
+      end
+
+      safe_join(tags, "\n")
+    end
+
+    def build_asset_tag(entry, url, nonce: nil)
+      if css_entry?(entry)
+        tag.link(rel: "stylesheet", href: url, nonce: nonce)
+      else
+        tag.script(src: url, type: "module", nonce: nonce)
+      end
+    end
+
+    def resolve_vite_entry(entry, source_dir)
+      entry.start_with?("#{source_dir}/", "/") ? entry : "#{source_dir}/#{entry}"
+    end
+
+    def vite_asset_url(file)
+      vite_prefix_asset_host("#{RailsVite.config.asset_prefix}/#{file}")
+    end
+
+    def css_entry?(entry)
+      CSS_EXTENSIONS.match?(entry)
+    end
+
+    def vite_prefix_asset_host(path)
+      host = vite_resolve_asset_host
+      host ? "#{host}#{path}" : path
+    end
+
+    # Memoized per view instance (one per request). Safe for Proc hosts
+    # since each request gets a fresh ActionView::Base instance.
+    def vite_resolve_asset_host
+      return @_vite_asset_host if defined?(@_vite_asset_host)
+
+      @_vite_asset_host = begin
+        case (asset_host = Rails.application.config.action_controller.asset_host)
+        when String then asset_host.chomp("/")
+        when Proc then asset_host.call("")&.chomp("/")
+        end
+      rescue NoMethodError
+        nil
+      end
+    end
+  end
+end

data/lib/rails_vite/tasks.rb

@@ -0,0 +1,62 @@
+module RailsVite
+  module Tasks
+    extend self
+
+    BUN_CMD = defined?(Bundlebun) ? Bundlebun::Runner.binstub_or_binary_path : "bun"
+
+    COMMANDS = {
+      bun: {install: "#{BUN_CMD} install", add: "#{BUN_CMD} add -D", dev: "#{BUN_CMD} run vite", build: "#{BUN_CMD} run vite build"},
+      yarn: {install: "yarn install", add: "yarn add -D", dev: "yarn vite", build: "yarn vite build"},
+      pnpm: {install: "pnpm install", add: "pnpm add -D", dev: "pnpm vite", build: "pnpm vite build"},
+      npm: {install: "npm install", add: "npm install -D", dev: "npx vite", build: "npx vite build"}
+    }.freeze
+
+    LOCKFILES = {
+      bun: %w[bun.lockb bun.lock],
+      yarn: %w[yarn.lock],
+      pnpm: %w[pnpm-lock.yaml],
+      npm: %w[package-lock.json]
+    }.freeze
+
+    def install_command
+      command_for(:install)
+    end
+
+    def add_command(*packages)
+      "#{command_for(:add)} #{packages.join(" ")}"
+    end
+
+    def dev_command
+      command_for(:dev)
+    end
+
+    def build_command
+      command_for(:build)
+    end
+
+    def tool
+      tool_determined_by_lockfile || tool_determined_by_executable
+    end
+
+    private
+
+    def command_for(key)
+      COMMANDS.dig(tool, key) ||
+        raise("rails_vite: No suitable JS package manager found for '#{key}'. Ensure npm, yarn, pnpm, or bun is available.")
+    end
+
+    def tool_determined_by_lockfile
+      LOCKFILES.each do |tool_name, files|
+        return tool_name if files.any? { |f| File.exist?(f) }
+      end
+      nil
+    end
+
+    def tool_determined_by_executable
+      COMMANDS.each_key do |exe|
+        return exe if system "command -v #{exe} > /dev/null"
+      end
+      nil
+    end
+  end
+end

data/lib/rails_vite/version.rb

@@ -0,0 +1,3 @@
+module RailsVite
+  VERSION = "0.1.0.beta1"
+end

data/lib/rails_vite.rb

@@ -0,0 +1,30 @@
+require "json"
+require "digest"
+
+require_relative "rails_vite/errors"
+require_relative "rails_vite/manifest"
+require_relative "rails_vite/config"
+require_relative "rails_vite/tasks"
+require_relative "rails_vite/tag_helper"
+require_relative "rails_vite/version"
+
+module RailsVite
+  class << self
+    def config
+      @config ||= Config.new
+    end
+
+    def manifest
+      @manifest ||= Manifest.new(config.manifest_path)
+    end
+
+    def digest
+      manifest.digest
+    end
+
+    def reset!
+      @config = nil
+      @manifest = nil
+    end
+  end
+end

data/lib/tasks/rails_vite/build.rake

@@ -0,0 +1,29 @@
+namespace :vite do
+  desc "Install JavaScript dependencies"
+  task :install do
+    command = RailsVite::Tasks.install_command
+    system(command) || raise("rails_vite: Command install failed, ensure #{command.split.first} is installed")
+  end
+
+  desc "Build Vite assets for production"
+  task :build do
+    command = RailsVite::Tasks.build_command
+    system(command) || raise("rails_vite: Command build failed, ensure `#{command}` runs without errors")
+  end
+
+  Rake::Task["vite:build"].prereqs << :install unless ENV["SKIP_VITE_INSTALL"]
+
+  desc "Remove Vite build artifacts"
+  task :clobber do
+    rm_rf Rails.root.join("public", RailsVite.config.asset_prefix.delete_prefix("/"))
+  end
+end
+
+unless ENV["SKIP_VITE_BUILD"]
+  %w[assets:precompile test:prepare spec:prepare db:test:prepare].each do |t|
+    Rake::Task[t].enhance(["vite:build"]) if Rake::Task.task_defined?(t)
+    break if %w[test:prepare spec:prepare].include?(t) && Rake::Task.task_defined?(t)
+  end
+
+  Rake::Task["assets:clobber"].enhance(["vite:clobber"]) if Rake::Task.task_defined?("assets:clobber")
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification
+name: rails_vite
+version: !ruby/object:Gem::Version
+  version: 0.1.0.beta1
+platform: ruby
+authors:
+- Svyatoslav Kryukov
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Simple Vite integration for Rails, inspired by Laravel. No proxy, no
+  config duplication.
+email:
+- me@skryukov.dev
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/generators/rails_vite/install/install_generator.rb
+- lib/generators/rails_vite/install/templates/Procfile.dev.tt
+- lib/generators/rails_vite/install/templates/bin/dev
+- lib/generators/rails_vite/install/templates/vite.config.ts.tt
+- lib/rails_vite.rb
+- lib/rails_vite/auto_build.rb
+- lib/rails_vite/config.rb
+- lib/rails_vite/engine.rb
+- lib/rails_vite/errors.rb
+- lib/rails_vite/manifest.rb
+- lib/rails_vite/tag_helper.rb
+- lib/rails_vite/tasks.rb
+- lib/rails_vite/version.rb
+- lib/tasks/rails_vite/build.rake
+homepage: https://github.com/skryukov/rails_vite
+licenses:
+- MIT
+metadata:
+  bug_tracker_uri: https://github.com/skryukov/rails_vite/issues
+  changelog_uri: https://github.com/skryukov/rails_vite/blob/main/CHANGELOG.md
+  documentation_uri: https://github.com/skryukov/rails_vite/blob/main/README.md
+  homepage_uri: https://github.com/skryukov/rails_vite
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.3
+specification_version: 4
+summary: Vite integration for Rails
+test_files: []