prompt_objects 0.5.0 → 0.7.0

data/lib/prompt_objects/repositories/artifact_repository.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module PromptObjects
+  module Repositories
+    class ArtifactRepository < BaseRepository
+      Mutation = Data.define(:artifact, :cursor)
+
+      def upsert(**attributes)
+        upsert_with_cursor(**attributes).artifact
+      end
+
+      def upsert_with_cursor(workspace_session_id:, owner_po:, owner_thread_id:, producing_run_id:,
+                             title:, html:, mode: "replace", metadata: {}, id: nil)
+        raise ArgumentError, "unknown artifact mode: #{mode}" unless %w[replace version].include?(mode.to_s)
+
+        transaction do |db|
+          existing = if mode.to_s == "replace"
+                       db.get_first_row(<<~SQL, [workspace_session_id, title])
+                         SELECT * FROM artifacts
+                         WHERE workspace_session_id = ? AND title = ? AND mode = 'replace'
+                         ORDER BY updated_at DESC LIMIT 1
+                       SQL
+                     end
+          artifact_id = existing ? existing["id"] : (id || "artifact_#{SecureRandom.uuid}")
+          revision = existing ? existing["revision"].to_i + 1 : 1
+          now = Time.now.utc.iso8601
+          created_at = existing ? existing["created_at"] : now
+          params = [
+            artifact_id, workspace_session_id, owner_po, owner_thread_id,
+            producing_run_id, title, html, revision, mode.to_s, created_at,
+            now, JSON.generate(metadata)
+          ]
+          db.execute(<<~SQL, params)
+            INSERT INTO artifacts (
+              id, workspace_session_id, owner_po, owner_thread_id, producing_run_id,
+              title, html, revision, mode, created_at, updated_at, metadata
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            ON CONFLICT(id) DO UPDATE SET
+              owner_po = excluded.owner_po,
+              owner_thread_id = excluded.owner_thread_id,
+              producing_run_id = excluded.producing_run_id,
+              title = excluded.title,
+              html = excluded.html,
+              revision = excluded.revision,
+              mode = excluded.mode,
+              updated_at = excluded.updated_at,
+              metadata = excluded.metadata
+          SQL
+          row = db.get_first_row("SELECT * FROM artifacts WHERE id = ?", [artifact_id])
+          artifact = parse(row)
+          cursor = append_workspace_event(db, artifact)
+          Mutation.new(artifact: artifact, cursor: cursor)
+        end
+      end
+
+      def get(id)
+        row = read { |db| db.get_first_row("SELECT * FROM artifacts WHERE id = ?", [id]) }
+        row && parse(row)
+      end
+
+      def list(workspace_session_id:)
+        read do |db|
+          db.execute(
+            "SELECT * FROM artifacts WHERE workspace_session_id = ? ORDER BY updated_at ASC, id ASC",
+            [workspace_session_id]
+          ).map { |row| parse(row) }
+        end
+      end
+
+      def delete(id)
+        transaction do |db|
+          artifact = db.get_first_row("SELECT * FROM artifacts WHERE id = ?", [id])
+          next false unless artifact
+
+          db.execute("DELETE FROM artifacts WHERE id = ?", [id])
+          now = Time.now.utc.iso8601
+          db.execute(<<~SQL, [artifact["workspace_session_id"], id, now])
+            INSERT INTO workspace_events (
+              workspace_session_id, event_type, entity_type, entity_id, payload, created_at
+            ) VALUES (?, 'artifact_removed', 'artifact', ?, '{}', ?)
+          SQL
+          true
+        end
+      end
+
+      private
+
+      def append_workspace_event(db, artifact)
+        payload = { artifact_id: artifact.id, revision: artifact.revision }
+        db.execute(<<~SQL, [artifact.workspace_session_id, artifact.id, JSON.generate(payload), Time.now.utc.iso8601])
+          INSERT INTO workspace_events (
+            workspace_session_id, event_type, entity_type, entity_id, payload, created_at
+          ) VALUES (?, 'artifact_upserted', 'artifact', ?, ?, ?)
+        SQL
+        db.last_insert_row_id
+      end
+
+      def parse(row)
+        Domain::Artifact.new(
+          id: row["id"], workspace_session_id: row["workspace_session_id"],
+          owner_po: row["owner_po"], owner_thread_id: row["owner_thread_id"],
+          producing_run_id: row["producing_run_id"], title: row["title"], html: row["html"],
+          revision: row["revision"], mode: row["mode"], created_at: timestamp(row["created_at"]),
+          updated_at: timestamp(row["updated_at"]), metadata: json(row["metadata"])
+        )
+      end
+    end
+  end
+end

data/lib/prompt_objects/repositories/base_repository.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module PromptObjects
+  module Repositories
+    class BaseRepository
+      def initialize(store)
+        @store = store
+      end
+
+      private
+
+      def read(&block)
+        @store.with_connection(&block)
+      end
+
+      def transaction(&block)
+        @store.transaction(&block)
+      end
+
+      def json(value, default: {})
+        return default if value.nil?
+
+        JSON.parse(value, symbolize_names: true)
+      end
+
+      def json_array(value)
+        return [] if value.nil?
+
+        JSON.parse(value)
+      end
+
+      def timestamp(value)
+        value ? Time.parse(value) : nil
+      end
+    end
+  end
+end

data/lib/prompt_objects/repositories/definition_repository.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module PromptObjects
+  module Repositories
+    # Persists the exact Prompt Object definition used by a run.
+    class DefinitionRepository < BaseRepository
+      def attach(run_id:, definition:)
+        transaction do |db|
+          params = [
+            run_id, definition.po_name, definition.version, definition.prompt,
+            JSON.generate(definition.config), definition.provider, definition.model,
+            definition.capability_policy_version, Time.now.utc.iso8601
+          ]
+          db.execute(<<~SQL, params)
+            INSERT INTO run_definitions (
+              run_id, po_name, version, prompt, config, provider, model,
+              capability_policy_version, created_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+          SQL
+        end
+        get(run_id)
+      end
+
+      def get(run_id)
+        row = read { |db| db.get_first_row("SELECT * FROM run_definitions WHERE run_id = ?", [run_id]) }
+        return nil unless row
+
+        Domain::PromptObjectDefinition.new(
+          po_name: row["po_name"], version: row["version"], prompt: row["prompt"],
+          config: JSON.parse(row["config"]), provider: row["provider"], model: row["model"],
+          capability_policy_version: row["capability_policy_version"]
+        )
+      end
+    end
+  end
+end

data/lib/prompt_objects/repositories/env_data_repository.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module PromptObjects
+  module Repositories
+    class EnvDataRepository < BaseRepository
+      Mutation = Data.define(:entry, :cursor)
+      Removal = Data.define(:deleted, :cursor)
+
+      def set(**attributes)
+        set_with_cursor(**attributes).entry
+      end
+
+      def set_with_cursor(workspace_session_id:, key:, short_description:, value:, stored_by:)
+        now = Time.now.utc.iso8601
+        transaction do |db|
+          params = [
+            workspace_session_id, workspace_session_id, workspace_session_id,
+            key, short_description, JSON.generate(value), stored_by, now, now
+          ]
+          db.execute(<<~SQL, params)
+            INSERT INTO env_data (
+              root_thread_id, session_id, workspace_session_id, key,
+              short_description, value, stored_by, created_at, updated_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+            ON CONFLICT(root_thread_id, key) DO UPDATE SET
+              workspace_session_id = excluded.workspace_session_id,
+              session_id = excluded.session_id,
+              short_description = excluded.short_description,
+              value = excluded.value,
+              stored_by = excluded.stored_by,
+              updated_at = excluded.updated_at
+          SQL
+          cursor = append_event(db, workspace_session_id, "store", key, stored_by, now)
+          entry = parse(db.get_first_row(<<~SQL, [workspace_session_id, key]))
+            SELECT * FROM env_data WHERE workspace_session_id = ? AND key = ?
+          SQL
+          Mutation.new(entry: entry, cursor: cursor)
+        end
+      end
+
+      def get(workspace_session_id:, key:)
+        row = read do |db|
+          db.get_first_row(
+            "SELECT * FROM env_data WHERE workspace_session_id = ? AND key = ?",
+            [workspace_session_id, key]
+          )
+        end
+        row && parse(row)
+      end
+
+      def list(workspace_session_id:)
+        read do |db|
+          db.execute(
+            "SELECT * FROM env_data WHERE workspace_session_id = ? ORDER BY key ASC",
+            [workspace_session_id]
+          ).map { |row| parse(row) }
+        end
+      end
+
+      def delete(workspace_session_id:, key:, stored_by:)
+        delete_with_cursor(
+          workspace_session_id: workspace_session_id,
+          key: key,
+          stored_by: stored_by
+        ).deleted
+      end
+
+      def delete_with_cursor(workspace_session_id:, key:, stored_by:)
+        transaction do |db|
+          db.execute(
+            "DELETE FROM env_data WHERE workspace_session_id = ? AND key = ?",
+            [workspace_session_id, key]
+          )
+          next Removal.new(deleted: false, cursor: nil) unless db.changes.positive?
+
+          cursor = append_event(db, workspace_session_id, "delete", key, stored_by, Time.now.utc.iso8601)
+          Removal.new(deleted: true, cursor: cursor)
+        end
+      end
+
+      private
+
+      def append_event(db, workspace_session_id, action, key, stored_by, now)
+        payload = { action: action, key: key, stored_by: stored_by }
+        db.execute(<<~SQL, [workspace_session_id, key, JSON.generate(payload), now])
+          INSERT INTO workspace_events (
+            workspace_session_id, event_type, entity_type, entity_id, payload, created_at
+          ) VALUES (?, 'env_data_changed', 'env_data', ?, ?, ?)
+        SQL
+        db.last_insert_row_id
+      end
+
+      def parse(row)
+        {
+          id: row["id"], workspace_session_id: row["workspace_session_id"],
+          key: row["key"], short_description: row["short_description"],
+          value: JSON.parse(row["value"], symbolize_names: true), stored_by: row["stored_by"],
+          created_at: timestamp(row["created_at"]), updated_at: timestamp(row["updated_at"])
+        }.freeze
+      end
+    end
+  end
+end

data/lib/prompt_objects/repositories/event_repository.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module PromptObjects
+  module Repositories
+    class EventRepository < BaseRepository
+      def append_run_event(run_id:, kind:, data: {}, timestamp: Time.now.utc)
+        validate_kind!(kind)
+        transaction do |db|
+          run = db.get_first_row("SELECT * FROM runs WHERE id = ?", [run_id])
+          raise ArgumentError, "unknown run: #{run_id}" unless run
+
+          sequence = db.get_first_value(
+            "SELECT COALESCE(MAX(sequence), 0) + 1 FROM run_events WHERE run_id = ?",
+            [run_id]
+          )
+          occurred_at = timestamp.iso8601
+          workspace_cursor = append_workspace_event(
+            db,
+            workspace_session_id: run["workspace_session_id"],
+            event_type: "run_event",
+            entity_type: "run",
+            entity_id: run_id,
+            payload: { run_id: run_id, sequence: sequence, kind: kind.to_s, data: data },
+            created_at: occurred_at
+          )
+          params = [
+            run_id, sequence, workspace_cursor, run["workspace_session_id"],
+            run["thread_id"], kind.to_s, occurred_at, JSON.generate(data)
+          ]
+          db.execute(<<~SQL, params)
+            INSERT INTO run_events (
+              run_id, sequence, workspace_cursor, workspace_session_id,
+              thread_id, kind, timestamp, data
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+          SQL
+          parse_run_event(db.get_first_row("SELECT * FROM run_events WHERE id = last_insert_rowid()"))
+        end
+      end
+
+      def run_events(run_id:, after_sequence: 0)
+        rows = read do |db|
+          db.execute(
+            "SELECT * FROM run_events WHERE run_id = ? AND sequence > ? ORDER BY sequence ASC",
+            [run_id, after_sequence]
+          )
+        end
+        rows.map { |row| parse_run_event(row) }
+      end
+
+      def workspace_events(workspace_session_id:, after_cursor: 0, limit: 500)
+        read do |db|
+          rows = db.execute(<<~SQL, [workspace_session_id, after_cursor, limit])
+            SELECT * FROM workspace_events
+            WHERE workspace_session_id = ? AND id > ?
+            ORDER BY id ASC
+            LIMIT ?
+          SQL
+          rows.map do |row|
+            {
+              cursor: row["id"], workspace_session_id: row["workspace_session_id"],
+              event_type: row["event_type"], entity_type: row["entity_type"],
+              entity_id: row["entity_id"], payload: json(row["payload"]),
+              created_at: timestamp(row["created_at"])
+            }.freeze
+          end
+        end
+      end
+
+      def current_cursor(workspace_session_id:)
+        read do |db|
+          db.get_first_value(
+            "SELECT COALESCE(MAX(id), 0) FROM workspace_events WHERE workspace_session_id = ?",
+            [workspace_session_id]
+          )
+        end
+      end
+
+      private
+
+      def validate_kind!(kind)
+        return if Execution::Contracts::RUN_EVENT_KINDS.include?(kind.to_s)
+
+        raise ArgumentError, "unknown run event kind: #{kind}"
+      end
+
+      def append_workspace_event(db, workspace_session_id:, event_type:, entity_type:, entity_id:, payload:, created_at:)
+        db.execute(<<~SQL, [workspace_session_id, event_type, entity_type, entity_id, JSON.generate(payload), created_at])
+          INSERT INTO workspace_events (
+            workspace_session_id, event_type, entity_type, entity_id, payload, created_at
+          ) VALUES (?, ?, ?, ?, ?, ?)
+        SQL
+        db.last_insert_row_id
+      end
+
+      def parse_run_event(row)
+        Domain::RunEvent.new(
+          id: row["id"], run_id: row["run_id"], sequence: row["sequence"],
+          workspace_cursor: row["workspace_cursor"],
+          workspace_session_id: row["workspace_session_id"], thread_id: row["thread_id"],
+          kind: row["kind"], timestamp: timestamp(row["timestamp"]), data: json(row["data"])
+        )
+      end
+    end
+  end
+end

data/lib/prompt_objects/repositories/message_repository.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module PromptObjects
+  module Repositories
+    class MessageRepository < BaseRepository
+      def append(thread_id:, role:, content: nil, run_id: nil, turn_ordinal: nil,
+                 position: nil, from_po: nil, tool_calls: nil, tool_results: nil,
+                 usage: nil, message_uid: SecureRandom.uuid)
+        now = Time.now.utc.iso8601
+        transaction do |db|
+          position ||= next_position(db, thread_id, turn_ordinal)
+          params = [
+            thread_id, role.to_s, content, from_po, tool_calls && JSON.generate(tool_calls),
+            tool_results && JSON.generate(tool_results), usage && JSON.generate(usage), now,
+            message_uid, run_id, turn_ordinal, position
+          ]
+          db.execute(<<~SQL, params)
+            INSERT INTO messages (
+              session_id, role, content, from_po, tool_calls, tool_results, usage,
+              created_at, message_uid, run_id, turn_ordinal, position
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+          SQL
+          db.execute("UPDATE sessions SET updated_at = ?, last_activity_at = ? WHERE id = ?", [now, now, thread_id])
+          parse(db.get_first_row("SELECT * FROM messages WHERE id = last_insert_rowid()"))
+        end
+      end
+
+      def list(thread_id:, through_turn: nil, after_id: 0, limit: 100)
+        rows = read do |db|
+          if through_turn
+            db.execute(<<~SQL, [thread_id, through_turn, after_id, limit])
+              SELECT * FROM messages
+              WHERE session_id = ? AND (turn_ordinal IS NULL OR turn_ordinal <= ?) AND id > ?
+              ORDER BY COALESCE(turn_ordinal, 0), COALESCE(position, id), id
+              LIMIT ?
+            SQL
+          else
+            db.execute(<<~SQL, [thread_id, after_id, limit])
+              SELECT * FROM messages
+              WHERE session_id = ? AND id > ?
+              ORDER BY COALESCE(turn_ordinal, 0), COALESCE(position, id), id
+              LIMIT ?
+            SQL
+          end
+        end
+        rows.map { |row| parse(row) }
+      end
+
+      private
+
+      def next_position(db, thread_id, turn_ordinal)
+        return nil unless turn_ordinal
+
+        db.get_first_value(
+          "SELECT COALESCE(MAX(position), -1) + 1 FROM messages WHERE session_id = ? AND turn_ordinal = ?",
+          [thread_id, turn_ordinal]
+        )
+      end
+
+      def parse(row)
+        {
+          id: row["id"], message_uid: row["message_uid"], thread_id: row["session_id"],
+          run_id: row["run_id"], turn_ordinal: row["turn_ordinal"], position: row["position"],
+          role: row["role"].to_sym, content: row["content"], from_po: row["from_po"],
+          tool_calls: row["tool_calls"] && JSON.parse(row["tool_calls"], symbolize_names: true),
+          tool_results: row["tool_results"] && JSON.parse(row["tool_results"], symbolize_names: true),
+          usage: row["usage"] && JSON.parse(row["usage"], symbolize_names: true),
+          created_at: timestamp(row["created_at"])
+        }.freeze
+      end
+    end
+  end
+end