zuzu 0.0.1-java

data/lib/zuzu/agent.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Zuzu
+  # Prompt-based agent loop using <zuzu_tool_call> tags.
+  # Works with any instruction-following model — no native function-calling required.
+  class Agent
+    MAX_ITERATIONS = 10
+
+    TOOL_CALL_RE   = /<zuzu_tool_call>(.*?)<\/zuzu_tool_call>/m
+    TOOL_RESULT_RE = /<zuzu_tool_result>.*?<\/zuzu_tool_result>/m
+
+    SYSTEM_PROMPT = <<~PROMPT.strip
+      You are Zuzu, a helpful desktop AI assistant.
+
+      You have access to a sandboxed virtual filesystem called AgentFS. It is completely
+      separate from the host computer's filesystem. All file paths refer to AgentFS only.
+      You cannot access or modify any files on the host system.
+
+      Available tools — use the tag format shown below:
+
+      - write_file     : Write text to an AgentFS file. Args: path (string), content (string)
+      - read_file      : Read an AgentFS file. Args: path (string)
+      - list_directory : List an AgentFS directory. Args: path (string, default "/")
+      - run_command    : Run a sandboxed command against AgentFS. Args: command (string)
+                         Supported: ls [path], cat <path>, pwd, echo <text>
+      - http_get       : Fetch a public URL from the internet. Args: url (string)
+
+      To call a tool, output exactly this on its own line:
+      <zuzu_tool_call>{"name":"TOOL_NAME","args":{"key":"value"}}</zuzu_tool_call>
+
+      Rules:
+      - One tool call per turn. Wait for the <zuzu_tool_result> before calling another.
+      - After the task is complete, respond in plain text only (no XML tags of any kind).
+      - Do NOT verify or re-read files after writing them unless explicitly asked.
+      - Do NOT repeat a tool call you have already made.
+      - Never reference the host filesystem, shell environment, or paths like /home/user.
+      - Be concise and accurate.
+    PROMPT
+
+    def initialize(agent_fs:, memory:, llm:)
+      @fs     = agent_fs
+      @memory = memory
+      @llm    = llm
+    end
+
+    def process(user_message, &on_tool_call)
+      @memory.append(:user, user_message)
+
+      # Only system prompt + current message — no history injected into agent context.
+      # Prior non-tool-call responses cause models to skip tool use.
+      messages = [
+        { 'role' => 'system', 'content' => SYSTEM_PROMPT },
+        { 'role' => 'user',   'content' => user_message }
+      ]
+
+      final      = nil
+      seen_calls = Hash.new(0)
+
+      MAX_ITERATIONS.times do
+        response  = @llm.chat(messages)
+        content   = response['content'].to_s.strip
+        tool_calls = extract_tool_calls(content)
+
+        if tool_calls.empty?
+          final = content.gsub(TOOL_RESULT_RE, '').strip
+          break
+        end
+
+        messages << { 'role' => 'assistant', 'content' => content }
+
+        results = tool_calls.map do |tc|
+          sig = "#{tc['name']}:#{tc['args'].to_json}"
+          seen_calls[sig] += 1
+          if seen_calls[sig] > 2
+            $stderr.puts "[zuzu] loop detected for #{tc['name']}, breaking"
+            next "<zuzu_tool_result>#{JSON.generate({ name: tc['name'], result: 'Already done. Give your final answer now.' })}</zuzu_tool_result>"
+          end
+
+          out = ToolRegistry.execute(tc['name'], tc['args'], @fs)
+          $stderr.puts "[zuzu] tool #{tc['name']}(#{tc['args'].inspect}) => #{out.to_s[0, 120]}"
+          on_tool_call&.call(tc['name'], tc['args'], out)
+          "<zuzu_tool_result>#{JSON.generate({ name: tc['name'], result: out })}</zuzu_tool_result>"
+        end.join("\n")
+
+        messages << { 'role' => 'user', 'content' => results }
+      end
+
+      final ||= 'Max iterations reached.'
+      @memory.append(:assistant, final)
+      final
+    rescue StandardError => e
+      $stderr.puts "[zuzu] Agent error: #{e.message}"
+      $stderr.puts e.backtrace.first(10).map { |l| "  #{l}" }.join("\n")
+      error_msg = "Error: #{e.message}"
+      @memory.append(:assistant, error_msg)
+      error_msg
+    end
+
+    private
+
+    def extract_tool_calls(content)
+      content.scan(TOOL_CALL_RE).filter_map do |match|
+        data = JSON.parse(match[0].strip)
+        { 'name' => data['name'].to_s, 'args' => data['args'] || {} }
+      rescue JSON::ParserError
+        nil
+      end
+    end
+  end
+end

data/lib/zuzu/agent_fs.rb

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+
+module Zuzu
+  # Virtual filesystem backed by SQLite via JDBC.
+  # Provides sandboxed file I/O and a key-value store for the agent.
+  class AgentFS
+    SCHEMA = <<~SQL
+      CREATE TABLE IF NOT EXISTS fs_inodes (
+        id         INTEGER PRIMARY KEY AUTOINCREMENT,
+        type       TEXT NOT NULL CHECK(type IN ('file','dir')),
+        content    BLOB,
+        size       INTEGER DEFAULT 0,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS fs_dentries (
+        id        INTEGER PRIMARY KEY AUTOINCREMENT,
+        name      TEXT NOT NULL,
+        parent_id INTEGER NOT NULL,
+        inode_id  INTEGER NOT NULL,
+        UNIQUE(parent_id, name)
+      );
+      CREATE TABLE IF NOT EXISTS kv_store (
+        key        TEXT PRIMARY KEY,
+        value      TEXT,
+        updated_at INTEGER
+      );
+      CREATE TABLE IF NOT EXISTS tool_calls (
+        id          INTEGER PRIMARY KEY AUTOINCREMENT,
+        tool_name   TEXT,
+        input       TEXT,
+        output      TEXT,
+        started_at  REAL,
+        finished_at REAL
+      );
+    SQL
+
+    attr_reader :store
+
+    def initialize(store = nil)
+      @store = store || Store.new
+      bootstrap
+    end
+
+    # ── File operations ──────────────────────────────────────────
+
+    def write_file(path, content)
+      parts    = split(path)
+      filename = parts.pop
+      parent   = ensure_parents(parts)
+      now      = epoch
+      bytes    = content.to_s.to_java_bytes
+
+      dentry = find_dentry(parent, filename)
+      if dentry
+        @store.execute(
+          "UPDATE fs_inodes SET content = ?, size = ?, updated_at = ? WHERE id = ?",
+          [bytes, content.to_s.bytesize, now, dentry['inode_id']]
+        )
+      else
+        @store.execute(
+          "INSERT INTO fs_inodes (type, content, size, created_at, updated_at) VALUES ('file', ?, ?, ?, ?)",
+          [bytes, content.to_s.bytesize, now, now]
+        )
+        inode_id = @store.last_insert_id
+        @store.execute(
+          "INSERT INTO fs_dentries (name, parent_id, inode_id) VALUES (?, ?, ?)",
+          [filename, parent, inode_id]
+        )
+      end
+      true
+    end
+
+    def read_file(path)
+      inode = resolve(path)
+      return nil unless inode
+      row = @store.query_one("SELECT content FROM fs_inodes WHERE id = ?", [inode])
+      return nil unless row
+      blob = row['content']
+      blob.is_a?(Java::byte[]) ? String.from_java_bytes(blob) : blob.to_s
+    end
+
+    def list_dir(path = '/')
+      inode = resolve(path)
+      return [] unless inode
+      @store.query_all("SELECT name FROM fs_dentries WHERE parent_id = ?", [inode]).map { |r| r['name'] }
+    end
+
+    def mkdir(path)
+      parts   = split(path)
+      dirname = parts.pop
+      parent  = ensure_parents(parts)
+      return false if find_dentry(parent, dirname)
+
+      now = epoch
+      @store.execute(
+        "INSERT INTO fs_inodes (type, content, size, created_at, updated_at) VALUES ('dir', NULL, 0, ?, ?)",
+        [now, now]
+      )
+      inode_id = @store.last_insert_id
+      @store.execute(
+        "INSERT INTO fs_dentries (name, parent_id, inode_id) VALUES (?, ?, ?)",
+        [dirname, parent, inode_id]
+      )
+      true
+    end
+
+    def delete(path)
+      parts = split(path)
+      name  = parts.pop
+      parent = resolve_segments(parts)
+      return false unless parent
+      dentry = find_dentry(parent, name)
+      return false unless dentry
+      @store.execute("DELETE FROM fs_dentries WHERE id = ?", [dentry['id']])
+      @store.execute("DELETE FROM fs_inodes WHERE id = ?",   [dentry['inode_id']])
+      true
+    end
+
+    def exists?(path) = !resolve(path).nil?
+
+    def stat(path)
+      inode_id = resolve(path)
+      return nil unless inode_id
+      @store.query_one(
+        "SELECT id, type, size, created_at, updated_at FROM fs_inodes WHERE id = ?", [inode_id]
+      )
+    end
+
+    # ── Key-value store ──────────────────────────────────────────
+
+    def kv_set(key, value)
+      @store.execute(
+        "INSERT OR REPLACE INTO kv_store (key, value, updated_at) VALUES (?, ?, ?)",
+        [key, value, epoch]
+      )
+    end
+
+    def kv_get(key)
+      row = @store.query_one("SELECT value FROM kv_store WHERE key = ?", [key])
+      row && row['value']
+    end
+
+    def kv_delete(key)
+      @store.execute("DELETE FROM kv_store WHERE key = ?", [key])
+    end
+
+    def kv_list(prefix = '')
+      @store.query_all("SELECT key, value FROM kv_store WHERE key LIKE ?", ["#{prefix}%"])
+    end
+
+    # ── Tool-call audit log ──────────────────────────────────────
+
+    def record_tool_call(name, input, output, started_at, finished_at)
+      @store.execute(
+        "INSERT INTO tool_calls (tool_name, input, output, started_at, finished_at) VALUES (?, ?, ?, ?, ?)",
+        [name, input.to_s, output.to_s, started_at, finished_at]
+      )
+    end
+
+    private
+
+    def split(path) = path.to_s.split('/').reject(&:empty?)
+    def epoch       = (Time.now.to_f * 1000).to_i
+
+    def resolve(path)
+      resolve_segments(split(path))
+    end
+
+    def resolve_segments(parts)
+      current = 1  # root inode
+      parts.each do |name|
+        d = find_dentry(current, name)
+        return nil unless d
+        current = d['inode_id']
+      end
+      current
+    end
+
+    def find_dentry(parent_id, name)
+      @store.query_one(
+        "SELECT id, inode_id FROM fs_dentries WHERE parent_id = ? AND name = ?",
+        [parent_id, name]
+      )
+    end
+
+    def ensure_parents(parts)
+      current = 1
+      parts.each do |name|
+        d = find_dentry(current, name)
+        if d
+          current = d['inode_id']
+        else
+          now = epoch
+          @store.execute(
+            "INSERT INTO fs_inodes (type, content, size, created_at, updated_at) VALUES ('dir', NULL, 0, ?, ?)",
+            [now, now]
+          )
+          inode_id = @store.last_insert_id
+          @store.execute(
+            "INSERT INTO fs_dentries (name, parent_id, inode_id) VALUES (?, ?, ?)",
+            [name, current, inode_id]
+          )
+          current = inode_id
+        end
+      end
+      current
+    end
+
+    def bootstrap
+      SCHEMA.split(';').each do |ddl|
+        next if ddl.strip.empty?
+        stmt = @store.connection.create_statement
+        stmt.execute_update(ddl)
+        stmt.close
+      end
+      now = epoch
+      @store.execute(
+        "INSERT OR IGNORE INTO fs_inodes (id, type, content, size, created_at, updated_at) VALUES (1, 'dir', NULL, 0, ?, ?)",
+        [now, now]
+      )
+    end
+  end
+end

data/lib/zuzu/app.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+require 'glimmer-dsl-swt'
+
+module Zuzu
+  class App
+    include Glimmer::UI::Application
+
+    USER_BG   = rgb(66, 133, 244)
+    ASSIST_BG = rgb(225, 235, 255)
+
+    attr_accessor :user_input
+
+    before_body do
+      @store    = Store.new
+      @fs       = AgentFS.new(@store)
+      @memory   = Memory.new(@store)
+      @llm      = LlmClient.new
+      @agent    = Agent.new(agent_fs: @fs, memory: @memory, llm: @llm)
+      @user_input = ''
+
+      @channels = [Channels::InApp.new(@agent)]
+      if Zuzu.config.channels.include?('whatsapp')
+        @channels << Channels::WhatsApp.new(@agent)
+      end
+      @channels.each(&:start)
+    end
+
+    after_body do
+      body_root.on_widget_disposed do
+        @channels.each(&:stop)
+        @store.close
+      end
+    end
+
+    body {
+      shell {
+        grid_layout 1, false
+        text Zuzu.config.app_name
+        size Zuzu.config.window_width, Zuzu.config.window_height
+
+        # ── Chat display ─────────────────────────────────────
+        scrolled_composite(:v_scroll) {
+          layout_data(:fill, :fill, true, true)
+
+          @chat_display = text(:multi, :read_only, :wrap) {
+            background :white
+            font name: 'Monospace', height: 13
+          }
+        }
+
+        # ── Input row ────────────────────────────────────────
+        composite {
+          layout_data(:fill, :fill, true, false)
+          grid_layout 3, false
+
+          @input_text = text(:border) {
+            layout_data(:fill, :fill, true, false)
+            text <=> [self, :user_input]
+            on_key_pressed do |e|
+              send_message if e.character == 13
+            end
+          }
+
+          button {
+            text 'Send'
+            on_widget_selected { send_message }
+          }
+
+          button {
+            text 'Admin Panel'
+            on_widget_selected { open_admin_panel }
+          }
+        }
+      }
+    }
+
+    def self.launch!(use_llamafile: false)
+      if use_llamafile
+        @llamafile = LlamafileManager.new
+        @llamafile.start!
+      end
+      launch
+    ensure
+      @llamafile&.stop!
+    end
+
+    private
+
+    def send_message
+      input = user_input.to_s.strip
+      return if input.empty?
+
+      self.user_input = ''
+      add_bubble(:user, input)
+
+      Thread.new do
+        begin
+          response = @agent.process(input) do |tool_name, args, result|
+            async_exec { add_bubble(:tool, "#{tool_name}(#{args.map { |k, v| "#{k}: #{v.to_s[0, 40]}" }.join(', ')}) → #{result.to_s[0, 80]}") }
+          end
+          async_exec { add_bubble(:assistant, response) }
+        rescue => e
+          $stderr.puts "[zuzu] Send error: #{e.message}"
+          async_exec { add_bubble(:assistant, "Error: #{e.message}") }
+        end
+      end
+    end
+
+    def add_bubble(role, msg)
+      prefix = case role
+               when :user      then "You: "
+               when :assistant then "Assistant: "
+               when :tool      then "  [tool] "
+               end
+      current   = @chat_display.swt_widget.get_text
+      separator = role == :tool ? "\n" : "\n\n"
+      separator = '' if current.empty?
+      @chat_display.swt_widget.set_text(current + separator + prefix + msg.to_s)
+      @chat_display.swt_widget.set_top_index(@chat_display.swt_widget.get_line_count)
+    end
+
+    def open_admin_panel
+      file_list_widget = nil
+
+      admin = shell {
+        text 'Admin Panel'
+        minimum_size 380, 500
+        grid_layout 1, false
+
+        label {
+          layout_data(:fill, :fill, true, false)
+          text 'AgentFS — Virtual File Browser'
+          font height: 12, style: :bold
+        }
+
+        file_list_widget = list(:single, :v_scroll, :border) {
+          layout_data(:fill, :fill, true, true)
+          font name: 'Monospace', height: 11
+        }
+
+        button {
+          layout_data(:fill, :fill, true, false)
+          text 'Create Test File'
+          on_widget_selected {
+            @fs.write_file('/test.txt', "Hello from AgentFS!\nCreated at: #{Time.now}")
+            populate_file_list(file_list_widget)
+          }
+        }
+
+        button {
+          layout_data(:fill, :fill, true, false)
+          text 'Clear Chat History'
+          on_widget_selected {
+            @memory.clear
+            message_box {
+              text 'Done'
+              message 'Conversation history cleared.'
+            }.open
+          }
+        }
+
+        button {
+          layout_data(:fill, :fill, true, false)
+          text 'Refresh'
+          on_widget_selected { populate_file_list(file_list_widget) }
+        }
+      }
+
+      populate_file_list(file_list_widget)
+      admin.open
+    end
+
+    def populate_file_list(file_list)
+      entries = walk_fs('/')
+      items = entries.empty? ? ['(empty)'] : entries
+      file_list.swt_widget.set_items(items.to_java(:string))
+    rescue => e
+      file_list.swt_widget.set_items(["Error: #{e.message}"].to_java(:string))
+    end
+
+    def walk_fs(path, indent = 0)
+      @fs.list_dir(path).flat_map do |name|
+        child = path == '/' ? "/#{name}" : "#{path}/#{name}"
+        stat  = @fs.stat(child)
+        if stat && stat['type'] == 'dir'
+          ["#{'  ' * indent}+ #{name}/"] + walk_fs(child, indent + 1)
+        else
+          ["#{'  ' * indent}  #{name}"]
+        end
+      end
+    end
+  end
+end

data/lib/zuzu/channels/base.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Zuzu
+  module Channels
+    # Abstract base class for message channels.
+    class Base
+      def initialize(agent)
+        @agent   = agent
+        @running = false
+      end
+
+      def start   = raise(NotImplementedError)
+      def stop    = raise(NotImplementedError)
+      def running? = @running
+
+      def handle(message)
+        @agent.process(message)
+      end
+    end
+  end
+end

data/lib/zuzu/channels/in_app.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Zuzu
+  module Channels
+    # The desktop GUI itself is the in-app channel. This is a no-op marker.
+    class InApp < Base
+      def start = @running = true
+      def stop  = @running = false
+    end
+  end
+end

data/lib/zuzu/channels/whatsapp.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'webrick'
+require 'json'
+require 'net/http'
+
+module Zuzu
+  module Channels
+    # WhatsApp Cloud API webhook receiver.
+    class WhatsApp < Base
+      API_BASE = 'https://graph.facebook.com/v19.0'
+
+      def start
+        port  = Integer(ENV.fetch('WHATSAPP_PORT', 9292))
+        @server = WEBrick::HTTPServer.new(
+          Port: port, Logger: WEBrick::Log.new(nil, 0), AccessLog: []
+        )
+        @server.mount_proc('/webhook') { |req, res| dispatch(req, res) }
+        @running = true
+        @thread  = Thread.new { @server.start }
+      end
+
+      def stop
+        @server&.shutdown
+        @thread&.join
+        @running = false
+      end
+
+      private
+
+      def dispatch(req, res)
+        if req.request_method == 'GET'
+          res.body = req.query['hub.challenge'].to_s
+        elsif req.request_method == 'POST'
+          payload = JSON.parse(req.body)
+          entry   = payload.dig('entry', 0, 'changes', 0, 'value')
+          msg     = entry&.dig('messages', 0)
+          if msg&.dig('type') == 'text'
+            text  = msg.dig('text', 'body')
+            to    = msg['from']
+            reply = handle(text)
+            send_reply(to, reply)
+          end
+          res.body = 'OK'
+        end
+        res.status = 200
+      end
+
+      def send_reply(to, text)
+        token    = ENV['WHATSAPP_TOKEN']
+        phone_id = ENV['WHATSAPP_PHONE_ID']
+        uri  = URI("#{API_BASE}/#{phone_id}/messages")
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true
+        req  = Net::HTTP::Post.new(uri, 'Content-Type' => 'application/json',
+                                        'Authorization' => "Bearer #{token}")
+        req.body = { messaging_product: 'whatsapp', to: to,
+                     type: 'text', text: { body: text } }.to_json
+        http.request(req)
+      end
+    end
+  end
+end

data/lib/zuzu/config.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Zuzu
+  # Central configuration singleton.
+  #
+  #   Zuzu.configure do |c|
+  #     c.app_name       = "My Agent"
+  #     c.llamafile_path = "models/my.llamafile"
+  #     c.port           = 8080
+  #   end
+  #
+  class Config
+    attr_accessor :port, :model, :channels, :log_level, :app_name,
+                  :window_width, :window_height
+
+    attr_reader :db_path, :llamafile_path
+
+    def initialize
+      @port           = 8080
+      @model          = 'LLaMA_CPP'
+      @db_path        = File.join('.zuzu', 'zuzu.db')
+      @llamafile_path = nil
+      @channels       = []
+      @log_level      = :info
+      @app_name       = 'Zuzu'
+      @window_width   = 860
+      @window_height  = 620
+    end
+
+    # Expand paths so relative paths resolve against the caller's directory,
+    # not whatever the current working directory happens to be at runtime.
+    def db_path=(path)
+      @db_path = path ? File.expand_path(path) : path
+    end
+
+    def llamafile_path=(path)
+      @llamafile_path = path ? File.expand_path(path) : path
+    end
+  end
+
+  @config = Config.new
+
+  def self.config
+    yield @config if block_given?
+    @config
+  end
+
+  class << self
+    alias_method :configure, :config
+  end
+end