rubino-agent 0.3.0

data/lib/rubino/jobs/cron_job_repository.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require "json"
+
+module Rubino
+  module Jobs
+    # Repository for cron job definitions. Plain CRUD on the +cron_jobs+
+    # table; execution is orchestrated by Jobs::Scheduler.
+    #
+    # The +DELIVERS+ constant documents the accepted values for the
+    # +deliver+ column, but it is NOT enforced here: validation of the
+    # +local+/+webhook+ enum lives in the dry-schema at the HTTP boundary
+    # (see Api::Schemas). Callers that bypass the HTTP layer can insert any
+    # string; Scheduler#deliver_if_needed only acts on the exact match
+    # +"webhook"+, treating anything else as no-op delivery.
+    class CronJobRepository
+      DELIVERS = %w[local webhook].freeze
+
+      def initialize(db: nil)
+        @db = db || Rubino.database.db
+      end
+
+      def create(name:, schedule:, prompt:, skills: [], model: nil, provider: nil, deliver: "local", enabled: true)
+        now = Time.now.utc.iso8601
+        id = SecureRandom.uuid
+        @db[:cron_jobs].insert(
+          id: id, name: name, schedule: schedule, prompt: prompt,
+          skills_json: JSON.generate(skills), model: model, provider: provider,
+          deliver: deliver, enabled: enabled, created_at: now, updated_at: now
+        )
+        find(id)
+      end
+
+      def find(id)
+        @db[:cron_jobs].where(id: id).first
+      end
+
+      def list(include_disabled: true)
+        ds = @db[:cron_jobs].order(:name)
+        ds = ds.where(enabled: true) unless include_disabled
+        ds.all
+      end
+
+      # Partial update. Unknown keys are silently dropped (whitelist via slice);
+      # +:skills+ accepts an Array of strings and is JSON-encoded into the
+      # +skills_json+ column.
+      # @return [Hash, nil] the refreshed row, or nil if the id does not exist.
+      def update(id, attrs)
+        return nil unless find(id)
+
+        attrs = attrs.transform_keys(&:to_sym).slice(:name, :schedule, :prompt, :skills, :model, :provider, :deliver,
+                                                     :enabled)
+        attrs[:skills_json] = JSON.generate(attrs.delete(:skills) || []) if attrs.key?(:skills)
+        attrs[:updated_at] = Time.now.utc.iso8601
+        @db[:cron_jobs].where(id: id).update(attrs)
+        find(id)
+      end
+
+      def set_enabled(id, enabled:)
+        update(id, enabled: enabled)
+      end
+
+      # Stamps +last_run_at+/+last_run_id+ after Scheduler#fire creates the run.
+      def record_run(id, run_id:)
+        now = Time.now.utc.iso8601
+        @db[:cron_jobs].where(id: id).update(last_run_at: now, last_run_id: run_id, updated_at: now)
+      end
+
+      def destroy!(id)
+        @db[:cron_jobs].where(id: id).delete
+      end
+    end
+  end
+end

data/lib/rubino/jobs/handlers/cleanup_sessions_job.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Rubino
+  module Jobs
+    module Handlers
+      # Cleans up old ended sessions beyond retention period.
+      class CleanupSessionsJob
+        RETENTION_DAYS = 30
+
+        def perform(payload)
+          retention = payload[:retention_days] || RETENTION_DAYS
+          cutoff = (Time.now - (retention * 86_400)).utc.iso8601
+
+          db = Rubino.database.db
+          old_sessions = db[:sessions]
+                         .where(status: "ended")
+                         .where { ended_at < cutoff }
+                         .select(:id)
+                         .all
+
+          repo = Session::Repository.new
+          old_sessions.each do |s|
+            repo.destroy!(s[:id])
+          end
+        end
+      end
+    end
+  end
+end
+
+# Register the handler
+Rubino::Jobs::Registry.register("CleanupSessionsJob", Rubino::Jobs::Handlers::CleanupSessionsJob)

data/lib/rubino/jobs/handlers/compact_session_job.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Rubino
+  module Jobs
+    module Handlers
+      # Triggers context compaction for a session that exceeded threshold.
+      class CompactSessionJob
+        def perform(payload)
+          session_id = payload[:session_id]
+          return unless session_id
+
+          compressor = Context::Compressor.new(session_id: session_id)
+          compressor.compact!
+        end
+      end
+    end
+  end
+end
+
+# Register the handler
+Rubino::Jobs::Registry.register("CompactSessionJob", Rubino::Jobs::Handlers::CompactSessionJob)

data/lib/rubino/jobs/handlers/distill_skill_job.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "yaml"
+
+module Rubino
+  module Jobs
+    module Handlers
+      # Variant B — deterministic post-turn skill distillation.
+      #
+      # Enqueued from Interaction::Lifecycle#enqueue_post_turn_jobs alongside
+      # ExtractMemoryJob. The GATE is fully deterministic (no model call):
+      #   - the run produced a non-empty final assistant answer (succeeded), AND
+      #   - the turn used >= TOOL_THRESHOLD tool calls (mirrors the reference "5+"), AND
+      #   - no existing skill already covers the work (kept simple here:
+      #     no skill whose name/description shares a salient keyword with the
+      #     user's task — a fresh skills dir always passes).
+      # Only on a gate-PASS do we spend ONE auxiliary-model call to distil the
+      # just-finished transcript into a SKILL.md candidate, which we then write.
+      # So: +1 LLM call per gate-pass, 0 otherwise.
+      class DistillSkillJob
+        TOOL_THRESHOLD = Integer(ENV.fetch("RA_DISTILL_TOOL_THRESHOLD", "5"))
+
+        NAME_RE = /\A[a-z0-9]+(?:-[a-z0-9]+)*\z/
+
+        DISTILL_SYSTEM = <<~SYS
+          You distil a just-finished agent task into a REUSABLE skill, or decline.
+          You are given the user's task and a transcript of the tools the agent ran
+          and its final answer. If — and only if — the work was a complex, multi-step,
+          REPEATABLE procedure that would help future similar tasks, output a skill.
+          If it was trivial, one-off, or not generalizable, decline.
+
+          Output ONLY a JSON object, no prose:
+          {"create": true, "name": "<kebab-case, <=64 chars>",
+           "description": "<one line: what it's for and WHEN it applies>",
+           "body": "<markdown: # Title then the proven step-by-step instructions, commands, pitfalls — generalized, not hard-coded to this one input>"}
+          or {"create": false, "reason": "<why not skill-worthy>"}
+        SYS
+
+        def perform(payload)
+          session_id = payload[:session_id] || payload["session_id"]
+          return unless session_id
+
+          messages = Session::Store.new.for_session(session_id)
+          return unless gate_passes?(messages)
+
+          candidate = distill(messages)
+          return unless candidate && candidate["create"] == true
+
+          write_skill(candidate)
+        rescue StandardError => e
+          Rubino.logger.warn(event: "jobs.distill_skill.error", error_class: e.class.name, message: e.message)
+          nil
+        end
+
+        private
+
+        # Deterministic gate — NO model call here.
+        def gate_passes?(messages)
+          succeeded?(messages) &&
+            tool_count(messages) >= TOOL_THRESHOLD &&
+            !already_covered?(messages)
+        end
+
+        def succeeded?(messages)
+          final = messages.reverse.find { |m| m.role == "assistant" && !m.content.to_s.strip.empty? }
+          !final.nil?
+        end
+
+        def tool_count(messages)
+          messages.count { |m| m.role == "tool" }
+        end
+
+        # "No skill already covering it": if the registry is empty, never covered.
+        # Otherwise, covered when the user's task shares a salient keyword with an
+        # existing skill's name/description. Deterministic, cheap, no model call.
+        def already_covered?(messages)
+          skills = registry.all
+          return false if skills.empty?
+
+          task = first_user_text(messages).to_s.downcase
+          task_words = task.scan(/[a-z]{4,}/).to_set
+          skills.any? do |s|
+            hay = "#{s.name} #{s.description}".downcase
+            hay.scan(/[a-z]{4,}/).any? { |w| task_words.include?(w) }
+          end
+        end
+
+        def first_user_text(messages)
+          messages.find { |m| m.role == "user" }&.content
+        end
+
+        # The single auxiliary-model call (counts as the +1 LLM call).
+        def distill(messages)
+          transcript = build_transcript(messages)
+          response = LLM::AuxiliaryClient.new.call(
+            task: "summarize",
+            messages: [
+              { role: "system", content: DISTILL_SYSTEM },
+              { role: "user", content: transcript }
+            ]
+          )
+          extract_json(response.content.to_s)
+        end
+
+        def build_transcript(messages)
+          parts = []
+          messages.each do |m|
+            case m.role
+            when "user"
+              parts << "USER TASK:\n#{m.content}"
+            when "tool"
+              parts << "TOOL #{m.tool_name if m.respond_to?(:tool_name)}: #{m.content.to_s[0, 400]}"
+            when "assistant"
+              next if m.content.to_s.strip.empty?
+
+              parts << "ASSISTANT: #{m.content.to_s[0, 800]}"
+            end
+          end
+          parts.join("\n\n")[0, 8000]
+        end
+
+        def extract_json(text)
+          start = text.index("{")
+          return nil unless start
+
+          depth = 0
+          (start...text.length).each do |i|
+            depth += 1 if text[i] == "{"
+            if text[i] == "}"
+              depth -= 1
+              return JSON.parse(text[start..i]) if depth.zero?
+            end
+          end
+          nil
+        rescue JSON::ParserError
+          nil
+        end
+
+        def write_skill(candidate)
+          name = candidate["name"].to_s.strip
+          desc = candidate["description"].to_s.tr("\n", " ").strip
+          body = candidate["body"].to_s
+          return unless valid?(name, desc, body)
+          return if registry.find(name) # don't overwrite
+
+          dir = File.join(skills_write_dir, name)
+          FileUtils.mkdir_p(dir)
+          path = File.join(dir, "SKILL.md")
+          content = "---\nname: #{name}\ndescription: #{yaml_scalar(desc)}\n---\n\n#{body}"
+          content << "\n" unless content.end_with?("\n")
+          File.write(path, content)
+
+          Metrics.counter(:skills_created_total).increment
+          Rubino.active_event_bus&.emit(
+            Interaction::Events::SKILL_CREATED, name: name, file_path: path
+          )
+          path
+        end
+
+        def valid?(name, desc, body)
+          name.match?(NAME_RE) && name.length <= 64 &&
+            !desc.empty? && desc.length <= 1024 && !body.strip.empty?
+        end
+
+        def yaml_scalar(text)
+          %("#{text.gsub('"', '\\"')}")
+        end
+
+        def skills_write_dir
+          dir = (Rubino.configuration.dig("skills", "paths") || [".rubino/skills"]).first
+          File.expand_path(dir.to_s)
+        end
+
+        def registry
+          @registry ||= Skills::Registry.new
+        end
+      end
+    end
+  end
+end
+
+# Register the handler
+Rubino::Jobs::Registry.register(
+  "DistillSkillJob", Rubino::Jobs::Handlers::DistillSkillJob
+)

data/lib/rubino/jobs/handlers/extract_memory_job.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Rubino
+  module Jobs
+    module Handlers
+      # Extracts memories from a completed session turn.
+      class ExtractMemoryJob
+        def perform(payload)
+          session_id = payload[:session_id]
+          return unless session_id
+
+          confirm(Memory::Backends.build.extract(session_id))
+        end
+
+        private
+
+        # Deterministic save confirmation (#87): the agent's "I'll remember X"
+        # narration is no signal that anything landed. Echo one line from the
+        # actual write path, mirroring the memory tool's
+        # "✓ done · memory · Memory added (id=…)" line in chat. Best-effort — a
+        # UI hiccup must never fail (and re-run) a job whose writes landed.
+        def confirm(stored)
+          facts = Array(stored).compact
+          return if facts.empty?
+
+          ids = facts.map { |f| f[:id].to_s[0, 8] }.join(", ")
+          Rubino.ui.note("✓ saved to memory · #{facts.size} fact#{"s" if facts.size != 1} (#{ids})")
+        rescue StandardError
+          nil
+        end
+      end
+    end
+  end
+end
+
+# Register the handler
+Rubino::Jobs::Registry.register("ExtractMemoryJob", Rubino::Jobs::Handlers::ExtractMemoryJob)

data/lib/rubino/jobs/handlers/summarize_session_job.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Rubino
+  module Jobs
+    module Handlers
+      # Generates or updates a session summary.
+      class SummarizeSessionJob
+        def perform(payload)
+          session_id = payload[:session_id]
+          return unless session_id
+
+          builder = Context::SummaryBuilder.new(session_id: session_id)
+          builder.build_and_save!
+        end
+      end
+    end
+  end
+end
+
+# Register the handler
+Rubino::Jobs::Registry.register("SummarizeSessionJob", Rubino::Jobs::Handlers::SummarizeSessionJob)

data/lib/rubino/jobs/queue.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require "json"
+
+module Rubino
+  module Jobs
+    # Manages the job queue backed by SQLite.
+    # Supports enqueue, dequeue, locking, and status queries.
+    class Queue
+      def initialize(db: nil, config: nil)
+        @db = db || Rubino.database.db
+        @config = config || Rubino.configuration
+      end
+
+      # Enqueues a new job
+      def enqueue(type, payload, priority: 100, run_at: nil)
+        now = Time.now.utc.iso8601
+        id = SecureRandom.uuid
+
+        @db[:jobs].insert(
+          id: id,
+          type: type,
+          status: "queued",
+          priority: priority,
+          payload_json: JSON.generate(payload),
+          attempts: 0,
+          max_attempts: @config.jobs_max_attempts,
+          run_at: run_at || now,
+          created_at: now,
+          updated_at: now
+        )
+
+        # If inline mode, execute immediately — but first drain any stale rows
+        # a previous inline run left orphaned (#84/#224). Inline mode has no
+        # background drainer, so a `queued` row whose enqueuing process was
+        # interrupted mid-run (e.g. the user quit the session while the
+        # post-turn extraction was still finishing) — run_job is called
+        # directly, never locked, and Interrupt is not a StandardError, so the
+        # row never reaches complete!/fail! — sits "queued" forever and is the
+        # behaviour #84 closed. Every inline enqueue means a live process is
+        # here and willing to drain, so reap those orphans on this boot.
+        if @config.jobs_mode == "inline"
+          reap_inline_orphans(before: id)
+          Runner.new.run_job(id)
+        end
+
+        id
+      end
+
+      # Dequeues the next available job (locks it)
+      def dequeue(worker_id:)
+        now = Time.now.utc.iso8601
+
+        job = @db[:jobs]
+              .where(status: "queued")
+              .where { run_at <= now }
+              .order(:priority, :run_at)
+              .first
+
+        return nil unless job
+
+        # Lock the job
+        updated = @db[:jobs]
+                  .where(id: job[:id], status: "queued")
+                  .update(
+                    status: "running",
+                    locked_at: now,
+                    locked_by: worker_id,
+                    updated_at: now
+                  )
+
+        # Return nil if another worker grabbed it first
+        updated > 0 ? @db[:jobs].where(id: job[:id]).first : nil
+      end
+
+      # Marks a job as completed
+      def complete!(job_id)
+        @db[:jobs].where(id: job_id).update(
+          status: "completed",
+          locked_at: nil,
+          locked_by: nil,
+          updated_at: Time.now.utc.iso8601
+        )
+      end
+
+      # Marks a job as failed, increments attempts
+      def fail!(job_id, error:)
+        job = @db[:jobs].where(id: job_id).first
+        return unless job
+
+        new_attempts = job[:attempts] + 1
+        # Inline mode has no background drainer, so re-queueing a failed job
+        # would leave it "queued" forever (#84) — mark it terminal ("failed")
+        # instead so `jobs list` is honest. Worker/manual modes keep the
+        # retry-with-backoff behavior until attempts are exhausted.
+        new_status =
+          if new_attempts >= job[:max_attempts]
+            "dead"
+          elsif @config.jobs_mode == "inline"
+            "failed"
+          else
+            "queued"
+          end
+
+        # Calculate retry time with backoff
+        backoff = @config.dig("jobs", "retry_backoff_seconds") || 30
+        retry_at = (Time.now + (backoff * new_attempts)).utc.iso8601
+
+        @db[:jobs].where(id: job_id).update(
+          status: new_status,
+          attempts: new_attempts,
+          last_error: error,
+          locked_at: nil,
+          locked_by: nil,
+          run_at: new_status == "queued" ? retry_at : job[:run_at],
+          updated_at: Time.now.utc.iso8601
+        )
+      end
+
+      # Lists jobs with optional filters
+      def list(status: nil, limit: 20)
+        dataset = @db[:jobs].order(Sequel.desc(:created_at)).limit(limit)
+        dataset = dataset.where(status: status) if status
+        dataset.all
+      end
+
+      # Finds one job by full id or short-id prefix (the 8-char ids the list
+      # renders — same prefix resolution the memory store gives /memory show).
+      # nil when nothing matches; the first match wins on an ambiguous prefix.
+      def find(id)
+        return nil if id.to_s.empty?
+
+        @db[:jobs].where(Sequel.like(:id, "#{id}%")).first
+      end
+
+      # Status counts for the whole queue (status => count), one grouped
+      # query — the in-chat /jobs header line (#187). {} when the queue is empty.
+      def counts
+        @db[:jobs].group_and_count(:status).to_h { |row| [row[:status], row[:count]] }
+      end
+
+      # Returns count of pending jobs
+      def pending_count
+        @db[:jobs].where(status: "queued").count
+      end
+
+      # Returns count of failed jobs — both the inline-mode terminal "failed"
+      # and the attempts-exhausted "dead" (the two states a human must act on;
+      # surfaced by the in-chat /status jobs line, #186).
+      def failed_count
+        @db[:jobs].where(status: %w[failed dead]).count
+      end
+
+      # Drains `queued` rows left orphaned by an interrupted prior inline run
+      # (#84/#224). Runs every still-queued, due, unlocked row that was
+      # enqueued before +before+ (the row this enqueue is about to run itself),
+      # so a turn whose extraction was interrupted is recovered on the next
+      # inline boot instead of sitting "queued" forever. Each is taken through
+      # run_job, which marks it completed / failed (inline) / dead terminally.
+      def reap_inline_orphans(before: nil)
+        now = Time.now.utc.iso8601
+        runner = Runner.new(db: @db)
+
+        dataset = @db[:jobs]
+                  .where(status: "queued", locked_by: nil)
+                  .where { run_at <= now }
+                  .order(:priority, :run_at)
+        dataset = dataset.exclude(id: before) if before
+
+        dataset.select_map(:id).each { |orphan_id| runner.run_job(orphan_id) }
+      end
+
+      # Cleans up old completed jobs
+      def cleanup!(older_than_days: 7)
+        cutoff = (Time.now - (older_than_days * 86_400)).utc.iso8601
+        @db[:jobs]
+          .where(status: "completed")
+          .where { created_at < cutoff }
+          .delete
+      end
+    end
+  end
+end

data/lib/rubino/jobs/registry.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Rubino
+  module Jobs
+    # Registry that maps job type strings to handler classes.
+    class Registry
+      @handlers = {}
+
+      class << self
+        # Registers a handler class for a job type
+        def register(type, handler_class)
+          @handlers[type.to_s] = handler_class
+        end
+
+        # Returns the handler class for a job type. Job types name classes
+        # under Jobs::Handlers, so an unregistered type is resolved straight
+        # from that namespace (triggering the Zeitwerk autoload) and cached.
+        # This makes lookup independent of load order: a handler can never be
+        # "unregistered" at run time just because nothing happened to touch
+        # its constant before the inline Runner executed at enqueue time (#81).
+        def handler_for(type)
+          @handlers[type.to_s] || resolve(type.to_s)
+        end
+
+        # Returns all registered job types
+        def registered_types
+          @handlers.keys
+        end
+
+        # Clears all registrations (useful for testing)
+        def reset!
+          @handlers = {}
+        end
+
+        private
+
+        def resolve(type)
+          @handlers[type] = Handlers.const_get(type, false)
+        rescue NameError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/rubino/jobs/runner.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Rubino
+  module Jobs
+    # Executes individual jobs by looking up handlers in the Registry.
+    class Runner
+      def initialize(db: nil)
+        @db = db || Rubino.database.db
+        @queue = Queue.new(db: @db)
+      end
+
+      # Runs a specific job by ID
+      def run_job(job_id)
+        job = @db[:jobs].where(id: job_id).first
+        return unless job
+
+        handler = Registry.handler_for(job[:type])
+        unless handler
+          @queue.fail!(job_id, error: "No handler registered for: #{job[:type]}")
+          return
+        end
+
+        payload = JSON.parse(job[:payload_json], symbolize_names: true)
+        run_id = record_run_start(job_id)
+
+        begin
+          Rubino.event_bus.emit(Interaction::Events::JOB_STARTED, type: job[:type])
+          handler.new.perform(payload)
+          @queue.complete!(job_id)
+          record_run_finish(run_id, status: "completed")
+          Rubino.event_bus.emit(Interaction::Events::JOB_FINISHED, type: job[:type])
+        rescue StandardError => e
+          @queue.fail!(job_id, error: e.message)
+          record_run_finish(run_id, status: "failed", error: e.message)
+          Rubino.event_bus.emit(Interaction::Events::JOB_FAILED, type: job[:type], error: e.message)
+        end
+      end
+
+      # Runs all pending jobs up to limit
+      def run_pending(limit: 10)
+        worker_id = "runner-#{Process.pid}"
+        processed = 0
+
+        limit.times do
+          job = @queue.dequeue(worker_id: worker_id)
+          break unless job
+
+          run_job(job[:id])
+          processed += 1
+        end
+
+        processed
+      end
+
+      private
+
+      def record_run_start(job_id)
+        id = SecureRandom.uuid
+        @db[:job_runs].insert(
+          id: id,
+          job_id: job_id,
+          status: "running",
+          started_at: Time.now.utc.iso8601
+        )
+        id
+      end
+
+      def record_run_finish(run_id, status:, error: nil)
+        @db[:job_runs].where(id: run_id).update(
+          status: status,
+          finished_at: Time.now.utc.iso8601,
+          error: error
+        )
+      end
+    end
+  end
+end