ollama_agent 0.3.0 → 1.0.0

data/lib/ollama_agent/cli/repl_shared.rb

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+
+module OllamaAgent
+  class CLI
+    # Slash-command handlers shared by {Repl} and {TuiRepl}.
+    # rubocop:disable Metrics/ModuleLength, Layout/HashAlignment, Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/MethodLength, Style/RescueModifier, Style/NumericPredicate -- legacy Repl extraction
+    module ReplShared
+      SLASH_COMMANDS = {
+        "/help"     => "Show this help message",
+        "/status"   => "Show run budget, provider, memory summary",
+        "/session"  => "Show or switch session (usage: /session [id])",
+        "/memory"   => "Query long-term memory (usage: /memory [key])",
+        "/remember" => "Store a fact (usage: /remember key = value)",
+        "/clear"    => "Clear short-term context for this session",
+        "/config"   => "Show current agent configuration",
+        "/model"    => "Show or set chat model (usage: /model [name] | /model list)",
+        "/models"   => "List Ollama cloud catalog (ollama.com/api/tags); /model <name> to switch",
+        "/provider" => "Show or switch provider (usage: /provider [name])",
+        "/index"    => "Summarise the project repository index",
+        "/exit"     => "Exit the REPL"
+      }.freeze
+
+      private
+
+      def repl_memory
+        @memory || @agent.instance_variable_get(:@memory_manager)
+      end
+
+      def repl_budget
+        @budget || @agent.instance_variable_get(:@budget)
+      end
+
+      def slash_completer_candidates
+        base = SLASH_COMMANDS.keys
+        extras = plugin_slash_command_strings
+        (base + extras).uniq.sort
+      end
+
+      def plugin_slash_command_strings
+        OllamaAgent::Plugins::Registry.all_command_handlers.map { |h| h[:slash_command].to_s }
+      rescue StandardError
+        []
+      end
+
+      def handle_slash(line)
+        parts   = line.split(" ", 2)
+        command = parts[0].downcase
+        arg     = parts[1]
+
+        case command
+        when "/help"     then print_help
+        when "/status"   then print_status
+        when "/session"  then handle_session(arg)
+        when "/memory"   then handle_memory(arg)
+        when "/remember" then handle_remember(arg)
+        when "/clear"    then handle_clear
+        when "/config"   then print_config
+        when "/model"    then handle_model(arg)
+        when "/models"   then print_model_list
+        when "/provider" then handle_provider(arg)
+        when "/index"    then handle_index
+        else
+          check_plugin_commands(command, arg)
+        end
+      end
+
+      def print_help
+        @stdout.puts "\n\e[1mSlash commands:\e[0m"
+        SLASH_COMMANDS.each do |cmd, desc|
+          @stdout.puts "  \e[33m#{cmd.ljust(14)}\e[0m #{desc}"
+        end
+
+        plugin_cmds = OllamaAgent::Plugins::Registry.all_command_handlers rescue []
+        if plugin_cmds.any?
+          @stdout.puts "\n\e[1mPlugin commands:\e[0m"
+          plugin_cmds.each { |h| @stdout.puts "  \e[35m#{h[:slash_command]}\e[0m" }
+        end
+
+        @stdout.puts ""
+      end
+
+      def print_status
+        @stdout.puts "\n\e[1mStatus:\e[0m"
+        @stdout.puts "  Model:   #{@agent.model}"
+
+        if (b = repl_budget)
+          h = b.to_h
+          @stdout.puts "  Steps:   #{h[:steps]} / #{h[:max_steps]}"
+          @stdout.puts "  Tokens:  #{h[:tokens_used]} / #{h[:max_tokens]}"
+          @stdout.puts "  Cost:    $#{h[:cost_usd].round(4)}" if h[:cost_usd] > 0
+        end
+
+        mem = repl_memory
+        if mem
+          s = mem.summary
+          @stdout.puts "  Memory:  #{s[:short_term_entries]} short-term, " \
+                       "#{s[:session_keys]} session keys, " \
+                       "#{s[:long_term_namespaces]} LT namespaces"
+        end
+
+        @stdout.puts ""
+      end
+
+      def handle_session(arg)
+        if arg
+          @stdout.puts "  Switching session is not supported mid-run. " \
+                       "Restart with: ollama_agent ask --session #{arg} --resume"
+        else
+          id = @agent.instance_variable_get(:@session_id) rescue nil
+          @stdout.puts "  Current session: #{id || "(none)"}"
+        end
+      end
+
+      def handle_memory(arg)
+        return print_memory_list unless arg
+
+        mem = repl_memory
+        val = mem&.recall(arg)
+        if val
+          @stdout.puts "  \e[33m#{arg}\e[0m = #{val}"
+        else
+          @stdout.puts "  No memory found for: #{arg}"
+        end
+      end
+
+      def print_memory_list
+        mem = repl_memory
+        return @stdout.puts "  No memory manager attached" unless mem
+
+        entries = mem.list
+        if entries.empty?
+          @stdout.puts "  No long-term memories stored yet."
+        else
+          @stdout.puts "\n\e[1mLong-term memory:\e[0m"
+          entries.each { |k, v| @stdout.puts "  \e[33m#{k}\e[0m: #{v.to_s[0, 80]}" }
+        end
+        @stdout.puts ""
+      end
+
+      def handle_remember(arg)
+        return @stdout.puts "  Usage: /remember key = value" unless arg&.include?("=")
+
+        mem = repl_memory
+        key, value = arg.split("=", 2).map(&:strip)
+        mem&.remember(key, value, tier: :long_term)
+        @stdout.puts "  Stored: \e[33m#{key}\e[0m = #{value}"
+      end
+
+      def handle_clear
+        repl_memory&.flush_short_term!
+        @stdout.puts "  Short-term memory cleared."
+      end
+
+      def print_config
+        @stdout.puts "\n\e[1mConfiguration:\e[0m"
+        ivars = %i[@model @root @read_only @max_tokens @session_id @orchestrator]
+        ivars.each do |ivar|
+          val = @agent.instance_variable_get(ivar) rescue nil
+          next if val.nil?
+
+          @stdout.puts "  \e[36m#{ivar.to_s.delete_prefix("@").ljust(16)}\e[0m #{val}"
+        end
+        @stdout.puts ""
+      end
+
+      def handle_provider(arg)
+        if arg
+          @stdout.puts "  Provider switching mid-run is not yet supported. Restart with --provider #{arg}"
+          @stdout.puts "  Chat model can be changed anytime: /model <name>"
+        else
+          @stdout.puts "  Current provider: #{@agent.instance_variable_get(:@provider_name) || "ollama"}"
+        end
+      end
+
+      def handle_model(arg)
+        return print_current_model if arg.nil? || arg.strip.empty?
+
+        if arg.strip.casecmp("list").zero?
+          print_model_list
+          return
+        end
+
+        name = @agent.assign_chat_model!(arg)
+        @stdout.puts "  Chat model set to: #{name}"
+      rescue OllamaAgent::Error => e
+        @stdout.puts "  #{e.message}"
+      end
+
+      def print_current_model
+        @stdout.puts "  Current chat model: #{@agent.model}"
+      end
+
+      def print_model_list
+        names = @agent.list_cloud_model_names
+        if names.empty?
+          @stdout.puts "  Could not load the cloud model catalog (network or ollama.com)."
+          @stdout.puts "  Set OLLAMA_API_KEY if your account requires it; or set /model <name> manually."
+          return
+        end
+
+        @stdout.puts "\n\e[1mOllama cloud models (ollama.com/api/tags):\e[0m"
+        names.each { |n| @stdout.puts "  #{n}" }
+        @stdout.puts ""
+      end
+
+      def handle_index
+        root = @agent.instance_variable_get(:@root) || Dir.pwd
+        packer = OllamaAgent::Indexing::ContextPacker.new(root: root) rescue nil
+        if packer
+          @stdout.puts packer.repo_summary
+        else
+          @stdout.puts "  Index unavailable — require 'ollama_agent/indexing/context_packer' first"
+        end
+      end
+
+      def check_plugin_commands(command, arg)
+        handlers = OllamaAgent::Plugins::Registry.all_command_handlers rescue []
+        match    = handlers.find { |h| h[:slash_command] == command }
+
+        if match
+          match[:handler].call(arg, agent: @agent, stdout: @stdout)
+        else
+          @stdout.puts "  Unknown command: #{command}. Type /help for available commands."
+        end
+      end
+    end
+    # rubocop:enable Metrics/ModuleLength, Layout/HashAlignment, Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/MethodLength, Style/RescueModifier, Style/NumericPredicate
+  end
+end

data/lib/ollama_agent/cli/tui_repl.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require_relative "../tui"
+require_relative "../tui_user_prompt"
+require_relative "repl_shared"
+
+module OllamaAgent
+  class CLI
+    # Interactive REPL using TTY toolkit (box, table, markdown, prompt).
+    # rubocop:disable Metrics/ClassLength -- session loop + dashboard + agent wiring
+    class TuiRepl
+      include ReplShared
+
+      # rubocop:disable Metrics/ParameterLists -- mirrors {Repl} IO + optional memory injection
+      def initialize(agent:, tui:, stdout: $stdout, stderr: $stderr, memory: nil, budget: nil)
+        @agent = agent
+        @tui = tui
+        @stdout = stdout
+        @stderr = stderr
+        @memory = memory
+        @budget = budget
+        @assistant_hook_installed = false
+      end
+      # rubocop:enable Metrics/ParameterLists
+
+      # rubocop:disable Metrics/MethodLength -- straight-line session loop
+      def start
+        show_boot_dashboard
+        @tui.log(:info, "Session ready — type / then Tab to complete slash commands; /help lists all.")
+
+        loop do
+          line = read_user_line
+          break if line.nil?
+
+          line = line.to_s.chomp.strip
+          next if line.empty?
+
+          break if %w[/exit exit].include?(line)
+
+          if line.start_with?("/")
+            dispatch_slash(line)
+          else
+            run_agent_query(line)
+          end
+        end
+
+        @tui.goodbye
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      private
+
+      def read_user_line
+        @tui.ask_user_line(completion_candidates: slash_completer_candidates)
+      rescue Interrupt
+        nil
+      end
+
+      def dispatch_slash(line)
+        if line == "/status"
+          show_context_dashboard
+          return
+        end
+
+        handle_slash(line)
+      end
+
+      # rubocop:disable Metrics/MethodLength -- capture hook + errors + ensure
+      def run_agent_query(query)
+        ensure_assistant_hook
+        @capture_assistant = true
+        @pending_messages  = []
+        @agent.run(query)
+        flush_assistant_messages
+      rescue OllamaAgent::Error => e
+        @tui.print_error("Error: #{e.message}")
+      rescue StandardError => e
+        @tui.print_error("#{e.class}: #{e.message}")
+        @tui.print_error(e.backtrace.first(5).join("\n")) if ENV["OLLAMA_AGENT_DEBUG"] == "1"
+      ensure
+        @capture_assistant = false
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def ensure_assistant_hook
+        return if @assistant_hook_installed
+
+        @agent.hooks.on(:on_assistant_message) do |payload|
+          @pending_messages << payload[:message] if @capture_assistant
+        end
+        @assistant_hook_installed = true
+      end
+
+      def flush_assistant_messages
+        @pending_messages.each { |m| @tui.render_assistant_message(m) }
+        @pending_messages.clear
+      end
+
+      def show_boot_dashboard
+        show_context_dashboard
+      end
+
+      # rubocop:disable Metrics/MethodLength -- single dashboard assembly call
+      def show_context_dashboard
+        skills = skills_summary_for_agent
+        scripts = scripts_placeholder
+        mem_line = memory_summary_line
+        @tui.render_dashboard(
+          config: dashboard_config_hash,
+          skills: skills,
+          scripts: scripts,
+          status: "ACTIVE",
+          budget: repl_budget,
+          memory_line: mem_line
+        )
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def dashboard_config_hash
+        {
+          model: @agent.instance_variable_get(:@model),
+          endpoint: ENV.fetch("OLLAMA_BASE_URL", "localhost (default)")
+        }
+      end
+
+      def skills_summary_for_agent
+        enabled = @agent.instance_variable_get(:@skills_enabled)
+        paths   = @agent.instance_variable_get(:@skill_paths)
+        parts = []
+        parts << (enabled == false ? "off" : "on")
+        parts << "paths: #{Array(paths).join(", ")}" if paths && !paths.empty?
+        parts.join(" · ")
+      end
+
+      def scripts_placeholder
+        []
+      end
+
+      def memory_summary_line
+        mem = repl_memory
+        return nil unless mem
+
+        s = mem.summary
+        "#{s[:short_term_entries]} short-term · #{s[:session_keys]} session keys"
+      end
+    end
+    # rubocop:enable Metrics/ClassLength
+  end
+end

data/lib/ollama_agent/cli.rb

@@ -5,18 +5,28 @@ require "thor"
 require_relative "agent"
 require_relative "external_agents"
 require_relative "prompt_skills"
+require_relative "runtime/permissions"
+require_relative "plugins/registry"
+require_relative "plugins/loader"
 
 module OllamaAgent
   # Thor CLI for single-shot and interactive agent sessions.
   # rubocop:disable Metrics/ClassLength -- Thor commands and shared helpers
   class CLI < Thor
+    default_task :ask
+
     def self.exit_on_failure?
       true
     end
 
-    desc "ask [QUERY]", "Run a natural-language task (reads, search, patch)"
+    desc "ask [QUERY]", "Run a task, or interactive TUI when QUERY is omitted (default when no subcommand)"
     method_option :model, type: :string, desc: "Ollama model (default: OLLAMA_AGENT_MODEL or ollama-client default)"
-    method_option :interactive, type: :boolean, aliases: "-i", desc: "Interactive REPL"
+    method_option :interactive, type: :boolean, aliases: "-i",
+                                desc: "-i without --tui: line REPL; empty QUERY defaults to TUI"
+    method_option :tui, type: :boolean, default: false,
+                        desc: "TTY UI; on by default for empty QUERY unless line REPL (-i without --tui)"
+    method_option :tui_god, type: :boolean, default: false,
+                            desc: "With --tui: auto-select first option in interactive lists (dangerous)"
     method_option :read_only, type: :boolean, default: false, aliases: "-R",
                               desc: "Read/search only (no edit_file, write_file, patches, or delegation)"
     method_option :yes, type: :boolean, aliases: "-y", desc: "Apply patches without confirmation"
@@ -40,22 +50,27 @@ module OllamaAgent
                                desc: "Context window budget (OLLAMA_AGENT_MAX_TOKENS)"
     method_option :context_summarize, type: :boolean, default: false,
                                       desc: "Summarize dropped context vs sliding window"
+    method_option :provider, type: :string,
+                             desc: "Model provider: ollama (default) | openai | anthropic | auto"
+    method_option :permissions, type: :string,
+                                desc: "Permission profile: read_only | standard (default) | developer | full"
+    method_option :trace, type: :boolean, default: false,
+                          desc: "Enable structured trace logging (OLLAMA_AGENT_TRACE=1)"
     def ask(query = nil)
-      agent = build_agent
-
-      if options[:interactive]
-        start_interactive(agent)
-      elsif query
-        run_single_shot_agent!(agent, query)
-      else
-        puts Console.error_line("Error: provide a QUERY or use --interactive")
-        exit 1
-      end
+      load_plugins!
+      apply_session_interactive_tui_flags!(query)
+      validate_tui_options!
+      run_ask!(query)
     end
 
-    desc "orchestrate [QUERY]", "Like ask, with tools to list/delegate to external CLI agents (Claude, Gemini, …)"
+    desc "orchestrate [QUERY]", "Like ask, plus delegate to external CLI agents (Claude, Gemini, …)"
     method_option :model, type: :string, desc: "Ollama model (default: OLLAMA_AGENT_MODEL or ollama-client default)"
-    method_option :interactive, type: :boolean, aliases: "-i", desc: "Interactive REPL"
+    method_option :interactive, type: :boolean, aliases: "-i",
+                                desc: "-i without --tui: line REPL; empty QUERY defaults to TUI"
+    method_option :tui, type: :boolean, default: false,
+                        desc: "TTY UI; on by default for empty QUERY unless line REPL (-i without --tui)"
+    method_option :tui_god, type: :boolean, default: false,
+                            desc: "With --tui: auto-select first option in interactive lists (dangerous)"
     method_option :read_only, type: :boolean, default: false, aliases: "-R",
                               desc: "Read/search only (no edit_file, write_file, patches, or delegation)"
     method_option :yes, type: :boolean, aliases: "-y", desc: "Apply patches and run delegations without confirmation"
@@ -77,16 +92,10 @@ module OllamaAgent
     method_option :context_summarize, type: :boolean, default: false,
                                       desc: "Summarize dropped context vs sliding window"
     def orchestrate(query = nil)
-      agent = build_orchestrator_agent
-
-      if options[:interactive]
-        start_interactive(agent)
-      elsif query
-        run_single_shot_agent!(agent, query)
-      else
-        puts Console.error_line("Error: provide a QUERY or use --interactive")
-        exit 1
-      end
+      load_plugins!
+      apply_session_interactive_tui_flags!(query)
+      validate_tui_options!
+      run_orchestrate!(query)
     end
 
     desc "sessions", "List saved sessions for the current project root"
@@ -188,6 +197,53 @@ module OllamaAgent
 
     private
 
+    def run_ask!(query)
+      if session_tui?
+        start_tui_interactive { |up| build_agent(user_prompt: up, attach_stream: false) }
+        return
+      end
+
+      interactive_or_single_shot!(query) { build_agent }
+    end
+
+    def run_orchestrate!(query)
+      if session_tui?
+        start_tui_interactive { |up| build_orchestrator_agent(user_prompt: up, attach_stream: false) }
+        return
+      end
+
+      interactive_or_single_shot!(query) { build_orchestrator_agent }
+    end
+
+    def interactive_or_single_shot!(query)
+      agent = yield
+
+      if @session_interactive
+        start_interactive(agent)
+      elsif query
+        run_single_shot_agent!(agent, query)
+      else
+        puts Console.error_line("Error: provide a QUERY or use --interactive")
+        exit 1
+      end
+    end
+
+    # Thor 1.5+ freezes +options+ after parse; keep effective flags on the instance.
+    def apply_session_interactive_tui_flags!(query)
+      interactive = options[:interactive]
+      tui = options[:tui]
+      if query.to_s.strip.empty? && !(interactive && !tui)
+        interactive = true
+        tui = true
+      end
+      @session_interactive = interactive
+      @session_tui = tui
+    end
+
+    def session_tui?
+      @session_interactive && @session_tui
+    end
+
     def ensure_improve_mode_only_automated!
       m = SelfImprovement::Modes.normalize(options[:mode])
       return if m == "automated"
@@ -341,8 +397,9 @@ module OllamaAgent
     # Build an Agent for the `ask` command.
     # Same root as `self_review` / interactive: cwd when unset (see README).
     # rubocop:disable Metrics/MethodLength, Metrics/AbcSize -- session + orchestrator + audit kwargs exceed limits
-    def build_agent
+    def build_agent(user_prompt: nil, attach_stream: true)
       orch  = orchestrator_mode?
+      perms = resolved_permissions
       agent = Agent.new(
         model: options[:model],
         root: resolved_root_for_self_review,
@@ -358,13 +415,25 @@ module OllamaAgent
         resume: options[:resume] || false,
         max_tokens: options[:max_tokens],
         context_summarize: options[:context_summarize],
+        provider_name: options[:provider],
+        permissions: perms,
+        user_prompt: user_prompt,
         **skill_agent_options
       )
-      attach_console_streamer(agent) if stream_enabled?
+      attach_console_streamer(agent) if stream_enabled? && attach_stream
       agent
     end
     # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
 
+    def resolved_permissions
+      profile = options[:permissions]&.to_sym
+      return nil unless profile
+
+      Runtime::Permissions.new(profile: profile)
+    rescue ArgumentError
+      nil
+    end
+
     def resolved_session_id
       return options[:session] if options[:session]
       return nil unless options[:resume]
@@ -380,7 +449,7 @@ module OllamaAgent
     end
 
     # rubocop:disable Metrics/MethodLength, Metrics/AbcSize -- mirrors build_agent; stream attachment adds one line
-    def build_orchestrator_agent
+    def build_orchestrator_agent(user_prompt: nil, attach_stream: true)
       agent = Agent.new(
         model: options[:model],
         root: resolved_root_for_self_review,
@@ -394,9 +463,10 @@ module OllamaAgent
         max_retries: options[:max_retries],
         max_tokens: options[:max_tokens],
         context_summarize: options[:context_summarize],
+        user_prompt: user_prompt,
         **skill_agent_options
       )
-      attach_console_streamer(agent) if stream_enabled?
+      attach_console_streamer(agent) if stream_enabled? && attach_stream
       agent
     end
     # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
@@ -429,35 +499,45 @@ module OllamaAgent
     end
 
     def start_interactive(agent)
-      puts Console.welcome_banner("Ollama Agent (type 'exit' to quit)")
-      use_readline = interactive_readline_usable?
+      CLI::Repl.new(agent: agent).start
+    end
 
-      loop do
-        input = interactive_readline_line(use_readline)
-        break if input.nil?
+    def validate_tui_options!
+      return unless @session_tui
+      return if @session_interactive
 
-        line = input.chomp
-        break if line == "exit"
+      puts Console.error_line("Error: --tui requires --interactive (-i)")
+      exit 1
+    end
 
-        agent.run(line)
-      end
+    def tui_god_mode?
+      options[:tui_god] || ENV.fetch("OLLAMA_AGENT_TUI_GOD_MODE", "0") == "1"
     end
 
-    def interactive_readline_usable?
-      require "readline"
-      true
-    rescue LoadError
-      false
+    def warn_if_tui_stream_conflict
+      return unless stream_enabled?
+
+      warn Console.error_line("ollama_agent: token streaming is disabled when using --tui.")
     end
 
-    def interactive_readline_line(use_readline)
-      if use_readline
-        Readline.readline(Console.prompt_prefix, true)
-      else
-        print Console.prompt_prefix
-        $stdin.gets
-      end
+    def start_tui_interactive
+      require_relative "cli/tui_repl"
+      warn_if_tui_stream_conflict
+      tui = OllamaAgent::TUI.new(god_mode: tui_god_mode?)
+      up = OllamaAgent::TuiUserPrompt.new(prompt: tui.prompt, stdout: $stdout)
+      agent = yield(up)
+      CLI::TuiRepl.new(agent: agent, tui: tui).start
+    end
+
+    def load_plugins!
+      root = resolved_root_for_self_review
+      Plugins::Loader.new(root: root).load_all(skip_gems: false)
+    rescue StandardError => e
+      warn "ollama_agent: plugin load error: #{e.message}" if ENV["OLLAMA_AGENT_DEBUG"] == "1"
     end
   end
   # rubocop:enable Metrics/ClassLength
+
+  require_relative "cli/repl_shared"
+  require_relative "cli/repl"
 end