roast-ai 0.3.1 → 0.4.1

data/lib/roast/workflow/expression_evaluator.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require "roast/workflow/command_executor"
-require "roast/workflow/expression_utils"
-
 module Roast
   module Workflow
     # Shared module for evaluating expressions in workflow steps

data/lib/roast/workflow/file_state_repository.rb

@@ -1,10 +1,5 @@
 # frozen_string_literal: true
 
-require "json"
-require "fileutils"
-require "roast/workflow/session_manager"
-require "roast/workflow/state_repository"
-
 module Roast
   module Workflow
     # File-based implementation of StateRepository

data/lib/roast/workflow/input_executor.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Roast
+  module Workflow
+    # Handles execution of input steps
+    class InputExecutor
+      def initialize(workflow, context_path, state_manager, workflow_executor = nil)
+        @workflow = workflow
+        @context_path = context_path
+        @state_manager = state_manager
+        @workflow_executor = workflow_executor
+      end
+
+      def execute_input(input_config)
+        # Interpolate the prompt if workflow executor is available
+        if @workflow_executor && input_config["prompt"]
+          interpolated_config = input_config.dup
+          interpolated_config["prompt"] = @workflow_executor.interpolate(input_config["prompt"])
+        else
+          interpolated_config = input_config
+        end
+
+        # Create and execute an InputStep
+        input_step = InputStep.new(
+          @workflow,
+          config: interpolated_config,
+          name: input_config["name"] || "input_#{Time.now.to_i}",
+          context_path: @context_path,
+        )
+
+        result = input_step.call
+
+        # Store in 'previous' for conditional checks
+        @workflow.output["previous"] = result
+        @state_manager.save_state("previous", result)
+
+        result
+      end
+    end
+  end
+end

data/lib/roast/workflow/input_step.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require "timeout"
+
+module Roast
+  module Workflow
+    class InputStep < BaseStep
+      attr_reader :prompt_text, :type, :required, :default, :timeout, :options, :step_name
+
+      def initialize(workflow, config:, **kwargs)
+        super(workflow, **kwargs)
+        parse_config(config)
+      end
+
+      def call
+        # Get user input based on the configured type
+        result = case type
+        when "boolean"
+          prompt_boolean
+        when "choice"
+          prompt_choice
+        when "password"
+          prompt_password
+        else
+          prompt_text_input
+        end
+
+        # Store the result in workflow state if a name was provided
+        store_in_state(result) if step_name
+
+        result
+      rescue Timeout::Error
+        handle_timeout
+      end
+
+      private
+
+      def parse_config(config)
+        @prompt_text = config["prompt"] || raise_config_error("Missing 'prompt' in input configuration")
+        @step_name = config["name"]
+        @type = config["type"] || "text"
+        @required = config.fetch("required", false)
+        @default = config["default"]
+        @timeout = config["timeout"]
+        @options = config["options"]
+
+        validate_config
+      end
+
+      def validate_config
+        if type == "choice" && options.nil?
+          raise_config_error("Missing 'options' for choice type input")
+        end
+
+        if type == "boolean" && default && ![true, false, "true", "false", "yes", "no"].include?(default)
+          raise_config_error("Invalid default value for boolean type: #{default}")
+        end
+      end
+
+      def prompt_text_input
+        loop do
+          result = if timeout
+            with_timeout { ::CLI::UI.ask(prompt_text, default: default) }
+          else
+            ::CLI::UI.ask(prompt_text, default: default)
+          end
+
+          if required && result.to_s.strip.empty?
+            puts ::CLI::UI.fmt("{{red:This field is required. Please provide a value.}}")
+            next
+          end
+
+          return result
+        end
+      end
+
+      def prompt_boolean
+        if timeout
+          with_timeout { ::CLI::UI.confirm(prompt_text, default: boolean_default) }
+        else
+          ::CLI::UI.confirm(prompt_text, default: boolean_default)
+        end
+      end
+
+      def prompt_choice
+        if timeout
+          with_timeout { ::CLI::UI.ask(prompt_text, options: options, default: default) }
+        else
+          ::CLI::UI.ask(prompt_text, options: options, default: default)
+        end
+      end
+
+      def prompt_password
+        require "io/console"
+
+        loop do
+          result = if timeout
+            with_timeout { prompt_password_with_echo_off }
+          else
+            prompt_password_with_echo_off
+          end
+
+          if required && result.to_s.strip.empty?
+            puts ::CLI::UI.fmt("{{red:This field is required. Please provide a value.}}")
+            next
+          end
+
+          return result
+        end
+      end
+
+      def prompt_password_with_echo_off
+        ::CLI::UI.with_frame_color(:blue) do
+          print("🔒 #{prompt_text} ")
+
+          password = if $stdin.tty?
+            # Use noecho for TTY environments
+            $stdin.noecho { $stdin.gets }.chomp
+          else
+            # Fall back to regular input for non-TTY environments
+            warn("[WARNING] Password will be visible (not running in TTY)")
+            $stdin.gets.chomp
+          end
+
+          puts # Add newline after password input
+          password
+        end
+      end
+
+      def boolean_default
+        case default
+        when true, "true", "yes"
+          true
+        when false, "false", "no"
+          false
+        end
+      end
+
+      def with_timeout(&block)
+        Timeout.timeout(timeout, &block)
+      end
+
+      def handle_timeout
+        puts ::CLI::UI.fmt("{{yellow:Input timed out after #{timeout} seconds}}")
+
+        if default
+          puts ::CLI::UI.fmt("{{yellow:Using default value: #{default}}}")
+          default
+        elsif required
+          raise_config_error("Required input timed out with no default value")
+        end
+      end
+
+      def store_in_state(value)
+        workflow.output[step_name] = value
+      end
+
+      def raise_config_error(message)
+        raise WorkflowExecutor::ConfigurationError, message
+      end
+    end
+  end
+end

data/lib/roast/workflow/iteration_executor.rb

@@ -24,7 +24,6 @@ module Roast
         raise WorkflowExecutor::ConfigurationError, "Missing 'until' condition in repeat configuration" unless until_condition
 
         # Create and execute a RepeatStep
-        require "roast/workflow/repeat_step" unless defined?(RepeatStep)
         repeat_step = RepeatStep.new(
           @workflow,
           steps: steps,
@@ -64,7 +63,6 @@ module Roast
         raise WorkflowExecutor::ConfigurationError, "Missing 'steps' in each configuration" unless steps
 
         # Create and execute an EachStep
-        require "roast/workflow/each_step" unless defined?(EachStep)
         each_step = EachStep.new(
           @workflow,
           collection_expr: collection_expr,

data/lib/roast/workflow/output_handler.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "roast/workflow/file_state_repository"
-
 module Roast
   module Workflow
     # Handles output operations for workflows including saving final output and results
@@ -13,7 +11,7 @@ module Roast
           final_output = workflow.final_output.to_s
           return if final_output.empty?
 
-          state_repository = FileStateRepository.new
+          state_repository = StateRepositoryFactory.create(workflow.storage_type)
           output_file = state_repository.save_final_output(workflow, final_output)
           $stderr.puts "Final output saved to: #{output_file}" if output_file
         rescue => e

data/lib/roast/workflow/output_manager.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "roast/workflow/dot_access_hash"
-
 module Roast
   module Workflow
     # Manages workflow output, including both the key-value output hash

data/lib/roast/workflow/repeat_step.rb

@@ -55,7 +55,7 @@ module Roast
       private
 
       def save_iteration_state(iteration)
-        state_repository = FileStateRepository.new
+        state_repository = StateRepositoryFactory.create(workflow.storage_type)
 
         # Save the current iteration count in the state
         state_data = {

data/lib/roast/workflow/replay_handler.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require "roast/workflow/step_finder"
-require "roast/workflow/file_state_repository"
-
 module Roast
   module Workflow
     # Handles replay functionality for workflows
@@ -12,7 +9,7 @@ module Roast
 
       def initialize(workflow, state_repository: nil)
         @workflow = workflow
-        @state_repository = state_repository || FileStateRepository.new
+        @state_repository = state_repository || StateRepositoryFactory.create(workflow.storage_type)
         @processed = false
       end
 

data/lib/roast/workflow/resource_resolver.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require "open3"
-require "roast/resources"
-
 module Roast
   module Workflow
     # Handles resource resolution and target processing

data/lib/roast/workflow/session_manager.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require "fileutils"
-require "digest"
-
 module Roast
   module Workflow
     # Manages session creation, timestamping, and directory management

data/lib/roast/workflow/sqlite_state_repository.rb

@@ -0,0 +1,342 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Roast
+  module Workflow
+    # SQLite-based implementation of StateRepository
+    # Provides structured, queryable session storage with better performance
+    class SqliteStateRepository < StateRepository
+      DEFAULT_DB_PATH = File.expand_path("~/.roast/sessions.db")
+
+      def initialize(db_path: nil, session_manager: SessionManager.new)
+        super()
+
+        # Lazy load sqlite3 only when actually using SQLite storage
+        begin
+          require "sqlite3"
+        rescue LoadError
+          raise LoadError, "SQLite storage requires the 'sqlite3' gem. Please add it to your Gemfile or install it: gem install sqlite3"
+        end
+
+        @db_path = db_path || ENV["ROAST_SESSIONS_DB"] || DEFAULT_DB_PATH
+        @session_manager = session_manager
+        ensure_database
+      end
+
+      def save_state(workflow, step_name, state_data)
+        workflow.session_timestamp ||= @session_manager.create_new_session(workflow.object_id)
+
+        session_id = ensure_session(workflow)
+
+        @db.execute(<<~SQL, session_id, state_data[:order], step_name, state_data.to_json)
+          INSERT INTO session_states (session_id, step_index, step_name, state_data)
+          VALUES (?, ?, ?, ?)
+        SQL
+
+        # Update session's current step
+        @db.execute(<<~SQL, state_data[:order], session_id)
+          UPDATE sessions#{" "}
+          SET current_step_index = ?, updated_at = CURRENT_TIMESTAMP
+          WHERE id = ?
+        SQL
+      rescue => e
+        $stderr.puts "Failed to save state for step #{step_name}: #{e.message}"
+      end
+
+      def load_state_before_step(workflow, step_name, timestamp: nil)
+        session_id = find_session_id(workflow, timestamp)
+        return false unless session_id
+
+        # Find the state before the target step
+        result = @db.execute(<<~SQL, session_id, step_name)
+          SELECT state_data, step_name
+          FROM session_states
+          WHERE session_id = ?
+            AND step_index < (
+              SELECT MIN(step_index)#{" "}
+              FROM session_states#{" "}
+              WHERE session_id = ? AND step_name = ?
+            )
+          ORDER BY step_index DESC
+          LIMIT 1
+        SQL
+
+        if result.empty?
+          # Try to find the latest state if target step doesn't exist
+          result = @db.execute(<<~SQL, session_id)
+            SELECT state_data, step_name
+            FROM session_states
+            WHERE session_id = ?
+            ORDER BY step_index DESC
+            LIMIT 1
+          SQL
+
+          if result.empty?
+            $stderr.puts "No state found for session"
+            return false
+          end
+        end
+
+        state_data = JSON.parse(result[0][0], symbolize_names: true)
+        loaded_step = result[0][1]
+        $stderr.puts "Found state from step: #{loaded_step} (will replay from here to #{step_name})"
+
+        # If no timestamp provided and workflow has no session, create new session and copy states
+        if !timestamp && workflow.session_timestamp.nil?
+          copy_states_to_new_session(workflow, session_id, step_name)
+        end
+
+        state_data
+      end
+
+      def save_final_output(workflow, output_content)
+        return if output_content.empty?
+
+        session_id = ensure_session(workflow)
+
+        @db.execute(<<~SQL, output_content, session_id)
+          UPDATE sessions#{" "}
+          SET final_output = ?, status = 'completed', updated_at = CURRENT_TIMESTAMP
+          WHERE id = ?
+        SQL
+
+        session_id
+      rescue => e
+        $stderr.puts "Failed to save final output: #{e.message}"
+        nil
+      end
+
+      # Additional query methods for the new capabilities
+
+      def list_sessions(status: nil, workflow_name: nil, older_than: nil, limit: 100)
+        conditions = []
+        params = []
+
+        if status
+          conditions << "status = ?"
+          params << status
+        end
+
+        if workflow_name
+          conditions << "workflow_name = ?"
+          params << workflow_name
+        end
+
+        if older_than
+          conditions << "created_at < datetime('now', ?)"
+          params << "-#{older_than}"
+        end
+
+        where_clause = conditions.empty? ? "" : "WHERE #{conditions.join(" AND ")}"
+
+        @db.execute(<<~SQL, *params)
+          SELECT id, workflow_name, workflow_path, status, current_step_index,#{" "}
+                 created_at, updated_at
+          FROM sessions
+          #{where_clause}
+          ORDER BY created_at DESC
+          LIMIT #{limit}
+        SQL
+      end
+
+      def get_session_details(session_id)
+        session = @db.execute(<<~SQL, session_id).first
+          SELECT * FROM sessions WHERE id = ?
+        SQL
+
+        return unless session
+
+        states = @db.execute(<<~SQL, session_id)
+          SELECT step_index, step_name, created_at
+          FROM session_states
+          WHERE session_id = ?
+          ORDER BY step_index
+        SQL
+
+        events = @db.execute(<<~SQL, session_id)
+          SELECT event_name, event_data, received_at
+          FROM session_events
+          WHERE session_id = ?
+          ORDER BY received_at
+        SQL
+
+        {
+          session: session,
+          states: states,
+          events: events,
+        }
+      end
+
+      def cleanup_old_sessions(older_than)
+        count = @db.changes
+        @db.execute(<<~SQL, "-#{older_than}")
+          DELETE FROM sessions
+          WHERE created_at < datetime('now', ?)
+        SQL
+        @db.changes - count
+      end
+
+      def add_event(workflow_path, session_id, event_name, event_data = nil)
+        # Find the session if session_id not provided
+        unless session_id
+          workflow_name = File.basename(File.dirname(workflow_path))
+          result = @db.execute(<<~SQL, workflow_name, "waiting")
+            SELECT id FROM sessions
+            WHERE workflow_name = ? AND status = ?
+            ORDER BY created_at DESC
+            LIMIT 1
+          SQL
+
+          raise "No waiting session found for workflow: #{workflow_name}" if result.empty?
+
+          session_id = result[0][0]
+        end
+
+        # Add the event
+        @db.execute(<<~SQL, session_id, event_name, event_data&.to_json)
+          INSERT INTO session_events (session_id, event_name, event_data)
+          VALUES (?, ?, ?)
+        SQL
+
+        # Update session status
+        @db.execute(<<~SQL, session_id)
+          UPDATE sessions#{" "}
+          SET status = 'running', updated_at = CURRENT_TIMESTAMP
+          WHERE id = ?
+        SQL
+
+        session_id
+      end
+
+      private
+
+      def ensure_database
+        FileUtils.mkdir_p(File.dirname(@db_path))
+        @db = SQLite3::Database.new(@db_path)
+        @db.execute("PRAGMA foreign_keys = ON")
+        create_schema
+      end
+
+      def create_schema
+        @db.execute_batch(<<~SQL)
+          CREATE TABLE IF NOT EXISTS sessions (
+            id TEXT PRIMARY KEY,
+            workflow_name TEXT NOT NULL,
+            workflow_path TEXT NOT NULL,
+            status TEXT NOT NULL DEFAULT 'running',
+            current_step_index INTEGER,
+            final_output TEXT,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+          );
+
+          CREATE TABLE IF NOT EXISTS session_states (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            session_id TEXT NOT NULL,
+            step_index INTEGER NOT NULL,
+            step_name TEXT NOT NULL,
+            state_data TEXT NOT NULL,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE CASCADE
+          );
+
+          CREATE TABLE IF NOT EXISTS session_events (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            session_id TEXT NOT NULL,
+            event_name TEXT NOT NULL,
+            event_data TEXT,
+            received_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE CASCADE
+          );
+
+          CREATE TABLE IF NOT EXISTS session_variables (
+            session_id TEXT NOT NULL,
+            key TEXT NOT NULL,
+            value TEXT NOT NULL,
+            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            PRIMARY KEY (session_id, key),
+            FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE CASCADE
+          );
+
+          -- Indexes for common queries
+          CREATE INDEX IF NOT EXISTS idx_sessions_status ON sessions(status);
+          CREATE INDEX IF NOT EXISTS idx_sessions_workflow_name ON sessions(workflow_name);
+          CREATE INDEX IF NOT EXISTS idx_sessions_created_at ON sessions(created_at);
+          CREATE INDEX IF NOT EXISTS idx_session_states_session_id ON session_states(session_id);
+          CREATE INDEX IF NOT EXISTS idx_session_events_session_id ON session_events(session_id);
+        SQL
+      end
+
+      def ensure_session(workflow)
+        session_id = generate_session_id(workflow)
+
+        # Check if session exists
+        existing = @db.execute("SELECT id FROM sessions WHERE id = ?", session_id).first
+        return session_id if existing
+
+        # Create new session
+        workflow_name = workflow.session_name || "unnamed"
+        workflow_path = workflow.file || "notarget"
+
+        @db.execute(<<~SQL, session_id, workflow_name, workflow_path)
+          INSERT INTO sessions (id, workflow_name, workflow_path)
+          VALUES (?, ?, ?)
+        SQL
+
+        session_id
+      end
+
+      def find_session_id(workflow, timestamp)
+        if timestamp
+          # Find by exact timestamp
+          generate_session_id(workflow, timestamp)
+        else
+          # Find latest session for this workflow
+          workflow_name = workflow.session_name || "unnamed"
+          workflow_path = workflow.file || "notarget"
+
+          result = @db.execute(<<~SQL, workflow_name, workflow_path)
+            SELECT id FROM sessions
+            WHERE workflow_name = ? AND workflow_path = ?
+            ORDER BY created_at DESC
+            LIMIT 1
+          SQL
+
+          result.empty? ? nil : result[0][0]
+        end
+      end
+
+      def generate_session_id(workflow, timestamp = nil)
+        timestamp ||= workflow.session_timestamp || @session_manager.create_new_session(workflow.object_id)
+        workflow_name = workflow.session_name || "unnamed"
+        workflow_path = workflow.file || "notarget"
+
+        # Generate a unique session ID based on workflow info and timestamp
+        file_hash = Digest::MD5.hexdigest(workflow_path)[0..7]
+        "#{workflow_name.parameterize.underscore}_#{file_hash}_#{timestamp}"
+      end
+
+      def copy_states_to_new_session(workflow, source_session_id, target_step_name)
+        # Create new session
+        new_timestamp = @session_manager.create_new_session(workflow.object_id)
+        workflow.session_timestamp = new_timestamp
+        new_session_id = ensure_session(workflow)
+
+        # Copy states up to the target step
+        @db.execute(<<~SQL, new_session_id, source_session_id, target_step_name, source_session_id)
+          INSERT INTO session_states (session_id, step_index, step_name, state_data)
+          SELECT ?, step_index, step_name, state_data
+          FROM session_states
+          WHERE session_id = ?
+            AND step_index < COALESCE(
+              (SELECT MIN(step_index) FROM session_states WHERE session_id = ? AND step_name = ?),
+              999999
+            )
+        SQL
+
+        true
+      end
+    end
+  end
+end

data/lib/roast/workflow/state_manager.rb

@@ -1,17 +1,15 @@
 # frozen_string_literal: true
 
-require "roast/workflow/file_state_repository"
-
 module Roast
   module Workflow
     # Manages workflow state persistence and restoration
     class StateManager
       attr_reader :workflow, :logger
 
-      def initialize(workflow, logger: nil)
+      def initialize(workflow, logger: nil, state_repository: nil, storage_type: nil)
         @workflow = workflow
         @logger = logger
-        @state_repository = FileStateRepository.new
+        @state_repository = state_repository || StateRepositoryFactory.create(storage_type)
       end
 
       # Save the current state after a step execution