ligarb 0.4.0 → 0.6.0

data/lib/ligarb/inotify.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+# Thin Fiddle wrapper for Linux inotify(7).
+# Non-Linux platforms will get LoadError from dlsym lookup.
+
+require "fiddle"
+
+module Ligarb
+  module Inotify
+    LIBC = Fiddle.dlopen(nil)
+
+    InotifyInit1 = Fiddle::Function.new(
+      LIBC["inotify_init1"],
+      [Fiddle::TYPE_INT],
+      Fiddle::TYPE_INT
+    )
+
+    InotifyAddWatch = Fiddle::Function.new(
+      LIBC["inotify_add_watch"],
+      [Fiddle::TYPE_INT, Fiddle::TYPE_VOIDP, Fiddle::TYPE_UINT32_T],
+      Fiddle::TYPE_INT
+    )
+
+    InotifyRmWatch = Fiddle::Function.new(
+      LIBC["inotify_rm_watch"],
+      [Fiddle::TYPE_INT, Fiddle::TYPE_INT],
+      Fiddle::TYPE_INT
+    )
+
+    # inotify event masks
+    IN_CLOSE_WRITE = 0x00000008
+    IN_CLOEXEC     = 0x00080000  # O_CLOEXEC on x86_64
+
+    # struct inotify_event fixed part: int wd, uint32 mask, uint32 cookie, uint32 len
+    EVENT_HEADER_SIZE = 16
+
+    # Watch a file for writes. Yields each time the file is written and closed.
+    # Blocks the calling thread. Caller should wrap in Thread.new.
+    def self.watch_file(path, &block)
+      fd = InotifyInit1.call(IN_CLOEXEC)
+      raise SystemCallError.new("inotify_init1", Fiddle.last_error) if fd < 0
+
+      io = IO.for_fd(fd, autoclose: true)
+      wd = add_watch(fd, path)
+
+      loop do
+        # IO.select releases GVL while waiting
+        IO.select([io])
+        buf = io.read_nonblock(4096, exception: false)
+        next if buf == :wait_readable || buf.nil?
+
+        # Parse events — may contain multiple events
+        offset = 0
+        while offset + EVENT_HEADER_SIZE <= buf.bytesize
+          _wd, mask, _cookie, name_len = buf.byteslice(offset, EVENT_HEADER_SIZE).unpack("iIII")
+          offset += EVENT_HEADER_SIZE + name_len
+
+          if mask & IN_CLOSE_WRITE != 0
+            block.call
+          end
+        end
+      rescue IOError, Errno::EBADF
+        break
+      end
+    ensure
+      io&.close rescue nil
+    end
+
+    def self.add_watch(fd, path)
+      wd = InotifyAddWatch.call(fd, path, IN_CLOSE_WRITE)
+      raise SystemCallError.new("inotify_add_watch: #{path}", Fiddle.last_error) if wd < 0
+      wd
+    end
+  end
+end

data/lib/ligarb/review_store.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require "json"
+require "securerandom"
+require "fileutils"
+
+module Ligarb
+  class ReviewStore
+    def initialize(base_dir)
+      @dir = File.join(base_dir, ".ligarb", "reviews")
+      @mutex = Mutex.new
+      FileUtils.mkdir_p(@dir)
+    end
+
+    def list
+      @mutex.synchronize do
+        Dir.glob(File.join(@dir, "*.json")).map { |f| read_json(f) }
+          .compact
+          .sort_by { |r| r["created_at"] }
+          .map { |r| summary(r) }
+      end
+    end
+
+    def get(id)
+      @mutex.synchronize do
+        get_unlocked(id)
+      end
+    end
+
+    def create(context:, message:)
+      @mutex.synchronize do
+        id = SecureRandom.uuid
+        now = Time.now.utc.iso8601
+
+        review = {
+          "id" => id,
+          "status" => "open",
+          "created_at" => now,
+          "context" => context,
+          "messages" => [
+            { "role" => "user", "content" => message, "timestamp" => now }
+          ]
+        }
+
+        write_json(id, review)
+        review
+      end
+    end
+
+    def add_message(id, role:, content:)
+      @mutex.synchronize do
+        review = get_unlocked(id)
+        return nil unless review
+
+        review["messages"] << {
+          "role" => role,
+          "content" => content,
+          "timestamp" => Time.now.utc.iso8601
+        }
+
+        write_json(id, review)
+        review
+      end
+    end
+
+    def update_context_files(id, files)
+      @mutex.synchronize do
+        review = get_unlocked(id)
+        return nil unless review
+
+        existing = review.dig("context", "uploaded_files") || []
+        review["context"]["uploaded_files"] = existing + files
+        write_json(id, review)
+        review
+      end
+    end
+
+    def update_status(id, status)
+      @mutex.synchronize do
+        review = get_unlocked(id)
+        return nil unless review
+
+        review["status"] = status
+        write_json(id, review)
+        review
+      end
+    end
+
+    def delete(id)
+      @mutex.synchronize do
+        path = file_path(id)
+        return false unless File.exist?(path)
+        File.delete(path)
+        true
+      end
+    end
+
+    private
+
+    def get_unlocked(id)
+      path = file_path(id)
+      return nil unless File.exist?(path)
+      review = read_json(path)
+      review["file_path"] = path if review
+      review
+    end
+
+    def file_path(id)
+      File.join(@dir, "#{id}.json")
+    end
+
+    def read_json(path)
+      JSON.parse(File.read(path))
+    rescue JSON::ParserError
+      nil
+    end
+
+    def write_json(id, data)
+      File.write(file_path(id), JSON.pretty_generate(data))
+    end
+
+    def summary(review)
+      {
+        "id" => review["id"],
+        "status" => review["status"],
+        "created_at" => review["created_at"],
+        "context" => review["context"],
+        "message_count" => review["messages"].size,
+        "last_message" => review["messages"].last
+      }
+    end
+  end
+end