zuzu 0.0.1-java

data/lib/zuzu/llamafile_manager.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Zuzu
+  # Manages the llamafile subprocess lifecycle.
+  class LlamafileManager
+    STARTUP_TIMEOUT  = 60   # seconds — models can take a while
+    SHUTDOWN_TIMEOUT = 5
+
+    attr_reader :pid
+
+    def initialize(path: Zuzu.config.llamafile_path, port: Zuzu.config.port)
+      @path   = path
+      @port   = port
+      @pid    = nil
+      @client = LlmClient.new(port: @port)
+    end
+
+    def start!
+      raise "llamafile already running (pid=#{@pid})" if running?
+      raise "llamafile not found: #{@path}" unless File.exist?(@path.to_s)
+
+      log_file = File.expand_path('llama.log', File.dirname(@path))
+      @pid = Process.spawn(
+        @path, '--server', '--port', @port.to_s, '--nobrowser',
+        out: log_file, err: log_file
+      )
+      Process.detach(@pid)
+      wait_for_ready
+      @pid
+    end
+
+    def stop!
+      return unless @pid
+      Process.kill('TERM', @pid) rescue nil
+      deadline = Time.now + SHUTDOWN_TIMEOUT
+      while Time.now < deadline
+        return (@pid = nil) unless alive?(@pid)
+        sleep 0.25
+      end
+      Process.kill('KILL', @pid) rescue nil
+      @pid = nil
+    end
+
+    def running?
+      @pid && alive?(@pid)
+    end
+
+    private
+
+    def wait_for_ready
+      deadline = Time.now + STARTUP_TIMEOUT
+      until @client.alive?
+        if Time.now > deadline
+          stop!
+          raise "llamafile failed to start within #{STARTUP_TIMEOUT}s"
+        end
+        sleep 1
+      end
+    end
+
+    def alive?(pid)
+      Process.kill(0, pid)
+      true
+    rescue Errno::ESRCH, Errno::EPERM, Errno::EINVAL
+      false
+    end
+  end
+end

data/lib/zuzu/llm_client.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'openssl'
+require 'json'
+require 'uri'
+
+module Zuzu
+  # HTTP client for llamafile's OpenAI-compatible API.
+  class LlmClient
+    def initialize(host: '127.0.0.1', port: Zuzu.config.port)
+      @host = host
+      @port = port
+    end
+
+    def chat(messages, temperature: 0.1)
+      body = {
+        model:       Zuzu.config.model,
+        messages:    messages,
+        temperature: temperature
+      }
+      data = post_json('/v1/chat/completions', body)
+      msg  = data.dig('choices', 0, 'message')
+      strip_eos(msg)
+    end
+
+    def alive?
+      uri = URI("http://#{@host}:#{@port}/v1/models")
+      Net::HTTP.get_response(uri).is_a?(Net::HTTPSuccess)
+    rescue StandardError
+      false
+    end
+
+    def stream(messages, &block)
+      body = { model: Zuzu.config.model, messages: messages, stream: true }
+      uri  = URI("http://#{@host}:#{@port}/v1/chat/completions")
+      req  = Net::HTTP::Post.new(uri, 'Content-Type' => 'application/json')
+      req.body = JSON.generate(body)
+
+      Net::HTTP.start(uri.host, uri.port) do |http|
+        http.request(req) do |response|
+          response.read_body do |chunk|
+            chunk.each_line do |line|
+              content = parse_sse(line)
+              block.call(content) if content
+            end
+          end
+        end
+      end
+    end
+
+    private
+
+    def post_json(path, body)
+      uri = URI("http://#{@host}:#{@port}#{path}")
+      req = Net::HTTP::Post.new(uri, 'Content-Type' => 'application/json')
+      req.body = JSON.generate(body)
+      res = Net::HTTP.start(uri.host, uri.port, read_timeout: 120,
+                            use_ssl: false) { |http| http.request(req) }
+      JSON.parse(res.body)
+    end
+
+    def strip_eos(msg)
+      return msg unless msg.is_a?(Hash) && msg['content'].is_a?(String)
+      msg['content'] = msg['content']
+        .gsub(/<\/?s>/, '')
+        .gsub(%r{\[/?INST\]}, '')
+        .strip
+      msg
+    end
+
+    def parse_sse(line)
+      line = line.strip
+      return nil if line.empty? || line == 'data: [DONE]'
+      return nil unless line.start_with?('data: ')
+      json = JSON.parse(line.sub('data: ', ''))
+      json.dig('choices', 0, 'delta', 'content')
+    rescue JSON::ParserError
+      nil
+    end
+  end
+end

data/lib/zuzu/memory.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Zuzu
+  # Conversation memory backed by the messages table.
+  class Memory
+    def initialize(store = nil)
+      @store = store || Store.new
+      bootstrap
+    end
+
+    def append(role, content)
+      @store.execute(
+        "INSERT INTO messages (role, content, created_at) VALUES (?, ?, ?)",
+        [role.to_s, content.to_s, (Time.now.to_f * 1000).to_i]
+      )
+    end
+
+    def recent(limit = 20)
+      @store.query_all(
+        "SELECT role, content FROM messages ORDER BY id DESC LIMIT ?", [limit]
+      ).reverse
+    end
+
+    def clear
+      @store.execute("DELETE FROM messages")
+    end
+
+    def context_for_llm(limit = 20)
+      recent(limit).map { |m| { 'role' => m['role'], 'content' => m['content'] } }
+    end
+
+    private
+
+    def bootstrap
+      @store.execute(<<~SQL)
+        CREATE TABLE IF NOT EXISTS messages (
+          id         INTEGER PRIMARY KEY AUTOINCREMENT,
+          role       TEXT NOT NULL,
+          content    TEXT NOT NULL,
+          created_at INTEGER NOT NULL
+        )
+      SQL
+    end
+  end
+end

data/lib/zuzu/store.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'jdbc/sqlite3'
+require 'fileutils'
+Jdbc::SQLite3.load_driver
+
+module Zuzu
+  # SQLite query layer used by AgentFS and Memory.
+  # One shared JDBC connection per db_path, guarded by a Mutex.
+  class Store
+    attr_reader :db_path
+
+    def initialize(db_path = Zuzu.config.db_path)
+      @db_path = db_path
+      @mutex   = Mutex.new
+    end
+
+    def connection
+      @connection ||= begin
+        FileUtils.mkdir_p(File.dirname(@db_path))
+        conn = Java::OrgSqlite::JDBC.new.connect(
+          "jdbc:sqlite:#{@db_path}", java.util.Properties.new
+        )
+        # Enable WAL for better concurrent read performance
+        stmt = conn.create_statement
+        stmt.execute_update("PRAGMA journal_mode=WAL")
+        stmt.close
+        conn
+      end
+    end
+
+    def execute(sql, params = [])
+      @mutex.synchronize do
+        ps = connection.prepare_statement(sql)
+        params.each_with_index { |v, i| ps.set_object(i + 1, v) }
+        ps.execute_update
+      ensure
+        ps&.close
+      end
+    end
+
+    def query_all(sql, params = [])
+      @mutex.synchronize do
+        ps = connection.prepare_statement(sql)
+        params.each_with_index { |v, i| ps.set_object(i + 1, v) }
+        rs   = ps.execute_query
+        meta = rs.meta_data
+        cols = (1..meta.column_count).map { |c| meta.get_column_name(c) }
+        rows = []
+        while rs.next
+          row = {}
+          cols.each { |col| row[col] = rs.get_object(col) }
+          rows << row
+        end
+        rows
+      ensure
+        rs&.close
+        ps&.close
+      end
+    end
+
+    def query_one(sql, params = [])
+      query_all(sql, params).first
+    end
+
+    def last_insert_id
+      @mutex.synchronize do
+        stmt = connection.create_statement
+        rs   = stmt.execute_query("SELECT last_insert_rowid()")
+        rs.next ? rs.get_long(1) : nil
+      ensure
+        rs&.close
+        stmt&.close
+      end
+    end
+
+    def close
+      @mutex.synchronize do
+        @connection&.close
+        @connection = nil
+      end
+    rescue StandardError
+      # Best-effort close — don't raise during shutdown
+    end
+  end
+end

data/lib/zuzu/tool_registry.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Zuzu
+  # Global registry of callable tools for the agent loop.
+  module ToolRegistry
+    Tool = Struct.new(:name, :description, :schema, :block, keyword_init: true)
+
+    @tools = {}
+
+    class << self
+      def register(name, description, schema, &block)
+        @tools[name.to_s] = Tool.new(
+          name: name.to_s, description: description,
+          schema: schema, block: block
+        )
+      end
+
+      def tools  = @tools.values
+      def find(name) = @tools[name.to_s]
+
+      def to_openai_schema
+        tools.map do |t|
+          { type: 'function', function: { name: t.name, description: t.description, parameters: t.schema } }
+        end
+      end
+
+      def execute(name, args, agent_fs)
+        tool = find(name) or return "Error: unknown tool '#{name}'"
+        started = Time.now.to_f
+        output = begin
+          tool.block.call(args, agent_fs)
+        rescue StandardError => e
+          "Error: #{e.message}"
+        end
+        finished = Time.now.to_f
+        agent_fs.record_tool_call(name, JSON.generate(args), output.to_s, started, finished)
+        output.to_s
+      end
+    end
+  end
+end

data/lib/zuzu/tools/file_tool.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+Zuzu::ToolRegistry.register(
+  'read_file', 'Read the contents of a file from the sandbox filesystem.',
+  { type: 'object', properties: { path: { type: 'string', description: 'Absolute path' } }, required: ['path'] }
+) { |args, fs| fs.read_file(args['path']) || "File not found: #{args['path']}" }
+
+Zuzu::ToolRegistry.register(
+  'write_file', 'Write content to a file in the sandbox filesystem.',
+  { type: 'object', properties: {
+    path:    { type: 'string', description: 'Absolute path' },
+    content: { type: 'string', description: 'Content to write' }
+  }, required: %w[path content] }
+) do |args, fs|
+  fs.write_file(args['path'], args['content'])
+  "Written #{args['content'].to_s.bytesize} bytes to #{args['path']}"
+end
+
+Zuzu::ToolRegistry.register(
+  'list_directory', 'List entries in a directory.',
+  { type: 'object', properties: { path: { type: 'string', description: 'Directory path (default "/")' } }, required: [] }
+) do |args, fs|
+  entries = fs.list_dir(args['path'] || '/')
+  entries.empty? ? '(empty)' : entries.join("\n")
+end

data/lib/zuzu/tools/shell_tool.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+Zuzu::ToolRegistry.register(
+  'run_command', 'Run a sandboxed command against AgentFS (NOT the host filesystem).',
+  { type: 'object', properties: { command: { type: 'string', description: 'Sandboxed command' } }, required: ['command'] }
+) do |args, fs|
+  cmd   = args['command'].to_s.strip
+  parts = cmd.split(/\s+/)
+  base  = parts[0]
+
+  case base
+  when 'ls'
+    path = parts[1] || '/'
+    stat = fs.stat(path)
+    if stat && stat['type'] == 'file'
+      "#{path} (file, #{stat['size']} bytes)"
+    else
+      entries = fs.list_dir(path)
+      entries.empty? ? '(empty directory)' : entries.join("\n")
+    end
+  when 'cat'
+    path = parts[1]
+    path ? (fs.read_file(path) || "File not found in AgentFS: #{path}") : 'Usage: cat <path>'
+  when 'pwd'
+    '/'
+  when 'echo'
+    parts[1..].join(' ')
+  else
+    "Error: '#{base}' is not available in the AgentFS sandbox. Supported: ls, cat, pwd, echo."
+  end
+end

data/lib/zuzu/tools/web_tool.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'openssl'
+require 'uri'
+
+Zuzu::ToolRegistry.register(
+  'http_get', 'Fetch a URL via HTTP GET (truncated to 8 KB).',
+  { type: 'object', properties: { url: { type: 'string', description: 'URL to fetch' } }, required: ['url'] }
+) do |args, _fs|
+  uri = URI.parse(args['url'].to_s)
+  raise ArgumentError, 'Only http/https supported' unless %w[http https].include?(uri.scheme)
+  res = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https',
+                        open_timeout: 10, read_timeout: 15,
+                        verify_mode: OpenSSL::SSL::VERIFY_NONE) { |h| h.get(uri.request_uri, 'User-Agent' => 'Zuzu/1.0') }
+  res.body.to_s.encode('UTF-8', invalid: :replace, undef: :replace).slice(0, 8192)
+end

data/lib/zuzu/version.rb

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

data/lib/zuzu.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+# Zuzu — JRuby desktop framework for local-first agentic apps.
+#
+# Author:   Abhishek Parolkar <apac.abhi@gmail.com>
+# License:  MIT
+# Homepage: https://github.com/parolkar/zuzu
+
+require 'zuzu/version'
+require 'zuzu/config'
+require 'zuzu/store'
+require 'zuzu/agent_fs'
+require 'zuzu/memory'
+require 'zuzu/llm_client'
+require 'zuzu/llamafile_manager'
+require 'zuzu/tool_registry'
+require 'zuzu/tools/file_tool'
+require 'zuzu/tools/shell_tool'
+require 'zuzu/tools/web_tool'
+require 'zuzu/agent'
+require 'zuzu/channels/base'
+require 'zuzu/channels/in_app'
+require 'zuzu/channels/whatsapp'
+require 'zuzu/app'

data/templates/app.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'zuzu'
+
+# ── Configure ────────────────────────────────────────────────────
+# Paths are automatically expanded to absolute, so relative paths work fine.
+Zuzu.configure do |c|
+  c.app_name       = 'My Assistant'
+  c.llamafile_path = File.join(__dir__, 'models', 'your-model.llamafile')
+  c.db_path        = File.join(__dir__, '.zuzu', 'zuzu.db')
+  c.port           = 8080
+  # c.channels     = ['whatsapp']
+end
+
+# ── Custom Tools ─────────────────────────────────────────────────
+Zuzu::ToolRegistry.register(
+  'greet', 'Greet a user by name.',
+  { type: 'object', properties: { name: { type: 'string' } }, required: ['name'] }
+) { |args, _fs| "Hello, #{args['name']}!" }
+
+# ── Launch ───────────────────────────────────────────────────────
+Zuzu::App.launch!(use_llamafile: true)

metadata

@@ -0,0 +1,137 @@
+--- !ruby/object:Gem::Specification
+name: zuzu
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: java
+authors:
+- Abhishek Parolkar
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: glimmer-dsl-swt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.30'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.30'
+- !ruby/object:Gem::Dependency
+  name: jdbc-sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.46'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.46'
+- !ruby/object:Gem::Dependency
+  name: webrick
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: bigdecimal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Zuzu is a framework for building local-first, privacy-respecting desktop
+  AI assistants using JRuby, Glimmer DSL for SWT, SQLite, and llamafile.
+email:
+- abhishek@parolkar.com
+executables:
+- zuzu
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- bin/setup
+- bin/zuzu
+- lib/zuzu.rb
+- lib/zuzu/agent.rb
+- lib/zuzu/agent_fs.rb
+- lib/zuzu/app.rb
+- lib/zuzu/channels/base.rb
+- lib/zuzu/channels/in_app.rb
+- lib/zuzu/channels/whatsapp.rb
+- lib/zuzu/config.rb
+- lib/zuzu/llamafile_manager.rb
+- lib/zuzu/llm_client.rb
+- lib/zuzu/memory.rb
+- lib/zuzu/store.rb
+- lib/zuzu/tool_registry.rb
+- lib/zuzu/tools/file_tool.rb
+- lib/zuzu/tools/shell_tool.rb
+- lib/zuzu/tools/web_tool.rb
+- lib/zuzu/version.rb
+- templates/app.rb
+homepage: https://github.com/parolkar/zuzu
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/parolkar/zuzu
+  source_code_uri: https://github.com/parolkar/zuzu
+  bug_tracker_uri: https://github.com/parolkar/zuzu/issues
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.7.2
+specification_version: 4
+summary: Local-first agentic desktop apps with JRuby.
+test_files: []