zuzu 0.2.2-java → 0.2.3-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b6098f883dec29f87b5dcece9c69f8e115608cfd89b9cf045fd442355fbf48c9
-  data.tar.gz: d9ffeb971f19158a6262401bdcadb7791bdbd70523c843dd6b7ac26cc3a4c536
+  metadata.gz: fd72fe083faded7ee6c7c7461125625f70a02a062da88eb9b28ed459cf767e40
+  data.tar.gz: 2096e3e9972ac19255f8b3f2ecdff467a979ac6cd9efe378f1bc226f625ce6aa
 SHA512:
-  metadata.gz: b7d6f2d65abfc635d0dceec2122a788d7d2cc03159969c9e06a1b03a45e73eb9c03bf430d5f1a6170a7aaa8c717961bc5c51311336cdf80ab4a3b28feb1dc8b4
-  data.tar.gz: b10535955c154eee0eaade46edb4ee5b1b9049e8e224cea1d49da58553d1bbd1ae263045977f9a1ac6d87dbb5bf0c7da62e26e73eb5ec0c4b3bf8152ba699f58
+  metadata.gz: 779b1e6821bcbe4199fa08868a8e0f4be6d197fae68e42ed6f46605f02c8e402a1e05e34c79b2abae71d7e4c06b4eaacd2a1b20c206eecf3ef64fc134d6762f4
+  data.tar.gz: 3453ba743830abb356d912a7f770fd27a7b22869a376830697b9419df11eea2c2cd9ce41fc01cbc827a5ea3370e913f05f8341a5c74a560111d30c40c899dedc

data/README.md

@@ -10,7 +10,7 @@ LLMs are simply a more expressive interface for exactly that orchestration. Zuzu
 
 - **Privacy by architecture.** The agent operates inside AgentFS — a sandboxed virtual filesystem backed by a single SQLite file. It cannot touch the host OS unless you explicitly open that door. There is no network call to make, no token to rotate, no terms of service that changes next quarter.
 
-- **Deployable like software, not like a service.** Package your app as a single `.jar`. Users pay, download, double-click, and run. No Docker. No cloud subscription. No infrastructure to maintain. The JVM handles cross-platform distribution the way it has for 30 years.
+- **Deployable like software, not like a service.** Package your app as a single `.jar` — or go further with `zuzu package` and produce a native installer (`.dmg`/`.app` on macOS, `.deb` on Linux, `.exe` on Windows) that bundles a minimal JRE via jlink. Users download, double-click, and run. No Java pre-installed. No Docker. No cloud subscription. No infrastructure to maintain.
 
 - **Built for regulated environments.** A therapist keeping session notes, an auditor running confidential analysis, a corporate team in a restricted environment — these are exactly the users who benefit most from powerful AI but are currently blocked by cloud dependency. A bundled LLM in a self-contained Java application needs no external approval to run.
 
@@ -312,6 +312,32 @@ java -jar my_app.jar                        # Linux / Windows
 > **Note:** Place your llamafile model in a `models/` directory alongside the
 > `.jar` — models are not bundled into the archive.
 
+### Packaging as a native installer (no Java required for users)
+
+After building the JAR, `zuzu package` asks if you want to go further:
+
+```
+Bundle into a self-contained native executable? (no Java required for users) [y/N]:
+```
+
+Type `y` and Zuzu uses **jpackage** (bundled with JDK 21+) to produce a native
+installer that includes a minimal JRE — users never need to install Java:
+
+| Platform | Output |
+|----------|--------|
+| macOS | `.dmg` with a drag-to-Applications `.app` |
+| Linux | `.deb` package |
+| Windows | `.exe` installer |
+
+The model file is not bundled (it can be gigabytes). After installing, users
+place it in the platform user-data directory that Zuzu prints at build time:
+
+```
+macOS:   ~/Library/Application Support/<AppName>/models/<model>.llamafile
+Linux:   ~/.local/share/<AppName>/models/<model>.llamafile
+Windows: %APPDATA%\<AppName>\models\<model>.llamafile
+```
+
 ---
 
 ## Configuration Reference

data/bin/zuzu

@@ -125,16 +125,106 @@ when 'package'
   puts 'Packaging app as zuzu-app.jar ...'
   puts '  (this may take a minute)'
   success = Bundler.with_unbundled_env { system(warble_bin, 'jar') }
-  if success
-    puts ''
-    jar = Dir['*.jar'].first || 'app.jar'
-    puts "Done! Created: #{jar}"
-    puts ''
-    puts 'Run it with:'
-    puts "  java -XstartOnFirstThread -jar #{jar}   # macOS"
-    puts "  java -jar #{jar}                        # Linux / Windows"
+  abort 'warble jar failed. Check output above for details.' unless success
+
+  jar = Dir['*.jar'].first || 'app.jar'
+  puts ''
+  puts "Done! Created: #{jar}"
+  puts ''
+  puts 'Run it with:'
+  puts "  java -XstartOnFirstThread -jar #{jar}   # macOS"
+  puts "  java -jar #{jar}                        # Linux / Windows"
+  puts ''
+
+  # ── jpackage: optional self-contained native executable ─────────────────
+  # jpackage (JDK 14+) bundles a minimal JRE via jlink so users don't need
+  # Java pre-installed. Model files can't be bundled — they're resolved from
+  # the platform user-data directory at runtime via the zuzu.model JVM property.
+
+  jpackage_bin = `which jpackage 2>/dev/null`.strip
+  if jpackage_bin.empty?
+    puts 'Tip: Install JDK 21+ to create a self-contained executable (no Java required for users).'
   else
-    abort 'warble jar failed. Check output above for details.'
+    print 'Bundle into a self-contained native executable? (no Java required for users) [y/N]: '
+    $stdout.flush
+    answer = $stdin.gets.to_s.strip.downcase
+
+    if answer == 'y' || answer == 'yes'
+      # ── detect / ask for model filename ───────────────────────────────────
+      model_files = Dir['models/*.llamafile']
+      model_name = if model_files.length == 1
+                     puts "Using model: #{File.basename(model_files.first)}"
+                     File.basename(model_files.first)
+                   elsif model_files.length > 1
+                     puts 'Model files found in models/:'
+                     model_files.each { |f| puts "  #{File.basename(f)}" }
+                     print 'Enter model filename: '
+                     $stdout.flush
+                     $stdin.gets.to_s.strip
+                   else
+                     print 'Enter model filename (e.g. llava-v1.5-7b-q4.llamafile): '
+                     $stdout.flush
+                     $stdin.gets.to_s.strip
+                   end
+      abort 'No model filename provided.' if model_name.to_s.empty?
+
+      print 'App version [1.0.0]: '
+      $stdout.flush
+      version_input = $stdin.gets.to_s.strip
+      app_version = version_input.empty? ? '1.0.0' : version_input
+
+      app_name = File.basename(Dir.pwd).gsub(/[^a-zA-Z0-9._-]/, '-')
+
+      platform = RbConfig::CONFIG['host_os']
+      pkg_type  = case platform
+                  when /darwin/ then 'dmg'
+                  when /linux/  then 'deb'
+                  else               'exe'
+                  end
+
+      FileUtils.mkdir_p('dist')
+
+      java_opts = [
+        '--enable-native-access=ALL-UNNAMED',
+        "-Dzuzu.model=#{model_name}"
+      ]
+      java_opts << '-XstartOnFirstThread' if platform =~ /darwin/
+
+      jpackage_args = [
+        jpackage_bin,
+        '--type',        pkg_type,
+        '--name',        app_name,
+        '--app-version', app_version,
+        '--input',       '.',
+        '--main-jar',    jar,
+        '--main-class',  'org.jruby.JarBootstrapMain',
+        '--dest',        'dist'
+      ]
+      java_opts.each { |opt| jpackage_args.push('--java-options', opt) }
+
+      puts ''
+      puts "Building native #{pkg_type.upcase} installer with jpackage..."
+      puts '  (this may take a minute)'
+      native_ok = system(*jpackage_args)
+
+      if native_ok
+        puts ''
+        puts 'Done! Native installer created in dist/'
+        pkg_file = Dir["dist/*.#{pkg_type}"].first
+        puts "  #{pkg_file}" if pkg_file
+        puts ''
+        puts 'Important — place your model file at:'
+        model_dest = case platform
+                     when /darwin/ then "  ~/Library/Application\\ Support/#{app_name}/models/#{model_name}"
+                     when /linux/  then "  ~/.local/share/#{app_name}/models/#{model_name}"
+                     else               "  %APPDATA%\\#{app_name}\\models\\#{model_name}"
+                     end
+        puts model_dest
+        puts '  (create the directory if it does not exist)'
+      else
+        warn 'jpackage failed. Check output above for details.'
+      end
+    end
   end
 
 when 'console'

data/lib/zuzu/config.rb

@@ -13,7 +13,7 @@ module Zuzu
     attr_accessor :port, :model, :channels, :log_level, :app_name,
                   :window_width, :window_height, :system_prompt_extras
 
-    attr_reader :db_path, :llamafile_path
+    attr_reader :db_path
 
     def initialize
       @port           = 8080
@@ -37,6 +37,28 @@ module Zuzu
     def llamafile_path=(path)
       @llamafile_path = path ? File.expand_path(path) : path
     end
+
+    # When running as a jpackage native executable, the model is NOT bundled
+    # in the app. Instead it lives in the platform user-data directory and its
+    # filename is injected via the `-Dzuzu.model=<filename>` JVM property set
+    # by jpackage at build time.
+    def llamafile_path
+      if defined?(Java) &&
+         (model_name = Java::JavaLang::System.getProperty('zuzu.model')) &&
+         !model_name.empty?
+        data_dir = case RbConfig::CONFIG['host_os']
+                   when /darwin/
+                     File.join(Dir.home, 'Library', 'Application Support', @app_name || 'Zuzu')
+                   when /mswin|mingw/
+                     File.join(ENV.fetch('APPDATA', Dir.home), @app_name || 'Zuzu')
+                   else
+                     File.join(Dir.home, '.local', 'share', @app_name || 'Zuzu')
+                   end
+        File.join(data_dir, 'models', model_name)
+      else
+        @llamafile_path
+      end
+    end
   end
 
   @config = Config.new

data/lib/zuzu/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Zuzu
-  VERSION = "0.2.2"
+  VERSION = "0.2.3"
 end

data/templates/AGENTS.md

@@ -451,6 +451,8 @@ Log line: `[zuzu] loop detected for <tool_name>, breaking`
 
 ## Packaging
 
+### Step 1 — Build the JAR
+
 ```bash
 bundle exec zuzu package
 ```
@@ -461,12 +463,42 @@ bundle exec zuzu package
 - Path resolution: `__dir__` inside a jar returns `uri:classloader:/` —
   app.rb already handles this with the `base` variable pattern
 
-Run the jar:
+Run the jar (requires Java 21+ installed):
 ```bash
 java -XstartOnFirstThread -jar my_app.jar   # macOS (SWT requires first thread)
 java -jar my_app.jar                        # Linux / Windows
 ```
 
+### Step 2 — Build a native installer (optional, no Java required for users)
+
+After the JAR is built, `zuzu package` prompts:
+
+```
+Bundle into a self-contained native executable? (no Java required for users) [y/N]:
+```
+
+Type `y`. Zuzu uses **jpackage** (included with JDK 21+) to bundle a minimal JRE
+via jlink and produce a platform-native installer:
+
+| Platform | Output in `dist/` |
+|----------|-------------------|
+| macOS | `.dmg` — drag-to-Applications `.app` bundle |
+| Linux | `.deb` package |
+| Windows | `.exe` installer |
+
+The model file cannot be bundled (too large). Zuzu injects the model filename as
+the `-Dzuzu.model` JVM property. At runtime, `Zuzu::Config#llamafile_path` resolves
+it from the platform user-data directory automatically:
+
+```
+macOS:   ~/Library/Application Support/<AppName>/models/<model>.llamafile
+Linux:   ~/.local/share/<AppName>/models/<model>.llamafile
+Windows: %APPDATA%\<AppName>\models\<model>.llamafile
+```
+
+`zuzu package` prints the exact path — tell your users to place the model there
+before launching the installed app.
+
 ---
 
 ## Debugging

data/templates/CLAUDE.md

@@ -53,10 +53,22 @@ What would you like to build today?
 ```bash
 bundle exec zuzu start      # launch the app
 bundle exec zuzu console    # IRB with Zuzu loaded — test tools interactively
-bundle exec zuzu package    # build standalone .jar
+bundle exec zuzu package    # build standalone .jar, then optionally a native installer
 bundle install              # sync gems after Gemfile changes
 ```
 
+### Distribution tiers
+
+| Command | Output | User requirement |
+|---------|--------|-----------------|
+| `zuzu package` → JAR only | `<app>.jar` | Java 21+ installed |
+| `zuzu package` → native (type `y` at prompt) | `.dmg` / `.deb` / `.exe` in `dist/` | Nothing — JRE bundled |
+
+For the native installer, the model file is NOT bundled. After install, users place it at:
+- **macOS:** `~/Library/Application Support/<AppName>/models/<model>.llamafile`
+- **Linux:** `~/.local/share/<AppName>/models/<model>.llamafile`
+- **Windows:** `%APPDATA%\<AppName>\models\<model>.llamafile`
+
 ## Core rules — always enforce these
 
 - Tools registered **before** `Zuzu::App.launch!` in `app.rb`

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: zuzu
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.3
 platform: java
 authors:
 - Abhishek Parolkar
@@ -85,10 +85,11 @@ description: Every installed application is an orchestrator of OS capabilities.
   the user's hardware — not in a data center. It uses JRuby and Glimmer DSL for SWT
   for the GUI, Mozilla's llamafile for local LLM inference, and SQLite (via AgentFS)
   as a sandboxed virtual filesystem the agent can read and write without touching
-  the host OS. Apps package as a single cross-platform .jar — users download, double-click,
-  run. No cloud. No subscriptions. No infrastructure to operate. Scaffolded projects
-  include CLAUDE.md and Claude Code skills pre-tuned to Zuzu's patterns, so coding
-  agents generate correct framework code from the start.
+  the host OS. Apps ship as a cross-platform .jar, or as a native installer (.dmg/.deb/.exe)
+  with a JRE bundled via jpackage — users download, double-click, and run with no
+  Java installation required. No cloud. No subscriptions. No infrastructure to operate.
+  Scaffolded projects include CLAUDE.md and Claude Code skills pre-tuned to Zuzu's
+  patterns, so coding agents generate correct framework code from the start.
 email:
 - abhishek@parolkar.com
 executables:
@@ -148,6 +149,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 3.7.2
 specification_version: 4
-summary: JRuby framework for AI-native desktop apps — local LLM, single .jar distribution,
-  Claude Code-ready scaffolding.
+summary: JRuby framework for AI-native desktop apps — local LLM, single .jar/.dmg/.exe/.deb
+  distribution, Claude Code-ready scaffolding. SQLite-backed AgentFS as a sandboxed
+  virtual filesystem for the agent. No cloud required.
 test_files: []