kward 0.79.0 → 0.80.1

data/lib/kward/cli/auth_commands.rb

@@ -22,12 +22,15 @@ module Kward
 
       # Writes the auth status output for the terminal CLI flow.
       def print_auth_status
-        config = safely_read_config.to_h
+        store = api_key_store
+        store.migrate_openrouter_config_key!
         lines = ["#{colored("Auth Status", :green, :bold)}", ""]
         lines << auth_status_line("OpenAI OAuth", File.exist?(OpenAIOAuth.default_auth_path), OpenAIOAuth.default_auth_path)
         lines << auth_status_line("Anthropic OAuth", File.exist?(AnthropicOAuth.default_auth_path), AnthropicOAuth.default_auth_path)
         lines << auth_status_line("GitHub OAuth", File.exist?(GithubOAuth.default_auth_path), GithubOAuth.default_auth_path)
-        lines << auth_status_line("OpenRouter API key", !config["openrouter_api_key"].to_s.empty? || !ENV["OPENROUTER_API_KEY"].to_s.empty?, ConfigFiles.config_path)
+        ProviderCatalog.api_key_providers.each do |provider|
+          lines << auth_status_line("#{provider.name} API key", store.configured?(provider.id), store.path)
+        end
         @prompt.say lines.join("\n")
       end
 
@@ -45,7 +48,11 @@ module Kward
           File.delete(path)
           removed << path
         end
-        removed << "OpenRouter API key" if OpenRouterAPIKey.new.logout
+        store = api_key_store
+        store.migrate_openrouter_config_key!
+        ProviderCatalog.api_key_providers.each do |provider|
+          removed << "#{provider.name} API key" if store.delete(provider.id)
+        end
 
         if removed.empty?
           @prompt.say "No saved credentials found."
@@ -54,29 +61,81 @@ module Kward
         end
       end
 
-      def login(provider: nil, oauth: nil)
-        provider = provider.to_s.downcase
-        if provider == "openrouter"
-          auth = oauth || OpenRouterAPIKey.new
-          path = auth.login(prompt: @prompt)
-          @prompt.say("#{colored("Saved", :green, :bold)} OpenRouter API key to #{path}")
+      def login(provider: nil, oauth: nil, auth_method: nil)
+        provider = normalized_login_provider(provider)
+        if api_key_login?(provider, auth_method)
+          login_with_api_key(provider)
           return
         end
 
         oauth ||= case provider
-                  when "github" then GithubOAuth.new
-                  when "anthropic", "claude" then AnthropicOAuth.new
+                  when "github", "copilot" then GithubOAuth.new
+                  when "anthropic" then AnthropicOAuth.new
                   else OpenAIOAuth.new
                   end
         path = oauth.login(prompt: @prompt)
         name = case provider
-               when "github" then "GitHub"
-               when "anthropic", "claude" then "Anthropic"
+               when "github", "copilot" then "GitHub"
+               when "anthropic" then "Anthropic"
                else "OpenAI"
                end
         @prompt.say("#{colored("Saved", :green, :bold)} #{name} OAuth login to #{path}")
       end
 
+      private
+
+      def api_key_store
+        @api_key_store ||= APIKeyStore.new
+      end
+
+      def normalized_login_provider(provider)
+        value = provider.to_s.downcase
+        return "openai" if value.empty?
+        return "anthropic" if ["anthropic", "claude"].include?(value)
+        return "copilot" if ["github", "copilot"].include?(value)
+
+        ProviderCatalog.fetch(value).id
+      end
+
+      def api_key_login?(provider, auth_method)
+        return true if auth_method == :api_key || auth_method == "api_key"
+
+        ProviderCatalog.fetch(provider).api_key? && !["openai", "anthropic", "copilot"].include?(provider)
+      end
+
+      def login_with_api_key(provider_id)
+        provider = ProviderCatalog.fetch(provider_id)
+        raise "#{provider.name} does not accept an API key" unless provider.api_key?
+
+        api_key = @prompt.ask("#{provider.name} API key:").to_s.strip
+        provider_config = provider_config_after_api_key_login(provider)
+        models = refresh_provider_models(provider, api_key)
+        path = api_key_store.store(provider.id, api_key)
+        ConfigFiles.update_config(provider_config) unless provider_config.empty?
+        @prompt.say("#{colored("Saved", :green, :bold)} #{provider.name} API key to #{path}")
+        @prompt.say("Loaded #{models.length} #{provider.name} model#{models.length == 1 ? "" : "s"}.") if models
+      end
+
+      def refresh_provider_models(provider, api_key)
+        return unless ProviderCatalog.runtime(provider.id).automatic_model_discovery?
+
+        model_catalog(provider_id: provider.id, api_key: api_key).refresh
+      end
+
+      def model_catalog(provider_id:, api_key:)
+        ModelCatalog.new(provider_id: provider_id, api_key: api_key)
+      end
+
+      def provider_config_after_api_key_login(provider)
+        return {} unless provider.id == "azure_openai"
+
+        AzureOpenAIConfig.new(
+          endpoint: @prompt.ask("Azure OpenAI endpoint:"),
+          deployment: @prompt.ask("Azure OpenAI deployment name:"),
+          api_version: @prompt.ask("Azure OpenAI API version:")
+        ).to_config
+      end
+
     end
   end
 end

data/lib/kward/cli/commands.rb

@@ -59,6 +59,7 @@ module Kward
             #{command.call("kward openrouter refresh")}           Refresh cached OpenRouter models
             #{command.call("kward pan")}                          Start Pan mode web UI
             #{command.call("kward rpc")}                          Start the JSON-RPC backend
+            #{command.call("kward transport")}                    Manage transport plugins
 
           #{heading.call("Commands")}
             #{command.call("help")}                               Show this help
@@ -74,6 +75,7 @@ module Kward
             #{command.call("openrouter refresh|list")}             Refresh or list cached OpenRouter models
             #{command.call("pan")}                                Start Pan mode web UI
             #{command.call("rpc")}                                Run the JSON-RPC backend for UI clients
+            #{command.call("transport list|status|run")}            Manage transport plugins
 
           #{heading.call("Options")}
             #{option.call("--working-directory=PATH")}             Run Kward from PATH
@@ -163,6 +165,11 @@ module Kward
             usage: "kward rpc",
             description: "Start the JSON-RPC backend for trusted local UI clients.",
             examples: ["kward rpc", "kward --working-directory ~/code/project rpc"]
+          },
+          "transport" => {
+            usage: "kward transport list|status [NAME]|run NAME [WORKSPACE]",
+            description: "Inspect or run trusted external transport plugins.",
+            examples: ["kward transport list", "kward transport status", "kward transport run telegram", "kward transport run telegram ~/code/project"]
           }
         }
       end

data/lib/kward/cli/git.rb

@@ -1,4 +1,5 @@
 require "open3"
+require "pathname"
 
 # Namespace for the Kward CLI agent runtime.
 module Kward
@@ -131,20 +132,40 @@ module Kward
         { path: path, staged: status[0] != " " && status[0] != "?", untracked: status == "??" }
       end
 
-      def git_commit(root, message)
-        before = git_lifecycle_hook("git_commit_before", root: root, payload: { message: message.to_s })
-        return { success: false, output: "Declined: #{before.decision.message || "git commit denied"}" } if before.denied? || before.approval_required?
+      def git_commit_for_agent(root, message:, paths: nil)
+        git_commit(root, message, paths: paths, stage_all: true, run_hooks: false)
+      end
+
+      def git_commit(root, message, paths: nil, stage_all: false, run_hooks: true)
+        if run_hooks
+          before = git_lifecycle_hook("git_commit_before", root: root, payload: { message: message.to_s })
+          return { success: false, output: "Declined: #{before.decision.message || "git commit denied"}" } if before.denied? || before.approval_required?
+        end
 
-        return git_commit_staged(root, message) if git_staged_changes?(root)
+        return git_commit_staged(root, message, run_hooks: run_hooks) if !stage_all && paths.nil? && git_staged_changes?(root)
 
-        add_output, add_status = Open3.capture2e("git", "add", "--all", chdir: root.to_s)
+        add_arguments = ["git", "add", "--all"]
+        add_arguments.concat(["--", *validated_git_commit_paths(root, paths)]) if paths
+        add_output, add_status = Open3.capture2e(*add_arguments, chdir: root.to_s)
         return { success: false, output: add_output } unless add_status.success?
 
-        git_commit_staged(root, message)
+        git_commit_staged(root, message, run_hooks: run_hooks)
       rescue StandardError => e
         { success: false, output: e.message }
       end
 
+      def validated_git_commit_paths(root, paths)
+        Array(paths).map do |path|
+          value = path.to_s
+          expanded = File.expand_path(value, root.to_s)
+          unless !value.empty? && !Pathname.new(value).absolute? && (expanded == root.to_s || expanded.start_with?("#{root}/"))
+            raise ArgumentError, "Git commit path must be workspace-relative: #{value}"
+          end
+
+          value
+        end
+      end
+
       def git_staged_changes?(root)
         _output, status = Open3.capture2e("git", "diff", "--cached", "--quiet", chdir: root.to_s)
         !status.success?
@@ -152,10 +173,12 @@ module Kward
         false
       end
 
-      def git_commit_staged(root, message)
+      def git_commit_staged(root, message, run_hooks: true)
         commit_output, commit_status = Open3.capture2e("git", "commit", "-m", message.to_s, chdir: root.to_s)
         result = { success: commit_status.success?, output: commit_output }
-        git_lifecycle_hook("git_commit_after", root: root, payload: { message: message.to_s, success: result[:success], output: result[:output] })
+        if run_hooks
+          git_lifecycle_hook("git_commit_after", root: root, payload: { message: message.to_s, success: result[:success], output: result[:output] })
+        end
         result
       rescue StandardError => e
         { success: false, output: e.message }

data/lib/kward/cli/memory_commands.rb

@@ -104,7 +104,7 @@ module Kward
       def prepare_memory_context(conversation, input)
         Memory::TurnContext.apply(conversation: conversation, input: input)
       rescue StandardError => e
-        warn "Memory retrieval failed: #{e.message}"
+        emit_warning "Memory retrieval failed: #{e.message}"
         nil
       end
 
@@ -120,7 +120,7 @@ module Kward
 
         summarize_memory(conversation, manager: manager)
       rescue StandardError => e
-        warn "Memory auto-summary failed: #{e.message}"
+        emit_warning "Memory auto-summary failed: #{e.message}"
         nil
       end
 

data/lib/kward/cli/plugins.rb

@@ -31,6 +31,7 @@ module Kward
       end
 
       def reload_plugins(conversation)
+        @prompt_templates = nil
         @plugin_registry = PluginRegistry.load(reserved_commands: reserved_slash_command_names)
         @prompt.update_slash_commands(slash_command_entries) if @prompt.respond_to?(:update_slash_commands)
         conversation.plugin_registry = @plugin_registry if conversation.respond_to?(:plugin_registry=)

data/lib/kward/cli/prompt_interface.rb

@@ -15,6 +15,8 @@ module Kward
         prompt_interface = load_prompt_interface
         return unless prompt_interface
 
+        @interactive_warning_sink_active = true
+        ConfigFiles.warning_sink = interactive_warning_sink
         @prompt = prompt_interface.new(
           slash_commands: slash_command_entries,
           overlay_settings: ConfigFiles.overlay_settings,
@@ -27,6 +29,7 @@ module Kward
           banner_message: Kward::PromptInterface::BANNER_MESSAGE,
           tab_keybindings: ConfigFiles.composer_tab_keybindings,
           prompt_history: PromptHistory.new(cwd: current_workspace_root),
+          workspace_root: current_workspace_root,
           editor_mode: ConfigFiles.editor_mode,
           editor_mode_source: -> { ConfigFiles.editor_mode },
           editor_auto_indent: ConfigFiles.editor_auto_indent?,
@@ -47,6 +50,28 @@ module Kward
         else
           @prompt.start
         end
+        flush_interactive_warnings
+      end
+
+      def interactive_warning_sink
+        @interactive_warning_sink ||= lambda do |message|
+          unless @interactive_warning_sink_active
+            warn message
+            next
+          end
+
+          if prompt_interface?
+            runtime_output(message)
+          else
+            (@pending_interactive_warnings ||= []) << message
+          end
+        end
+      end
+
+      def flush_interactive_warnings
+        warnings = @pending_interactive_warnings
+        @pending_interactive_warnings = []
+        Array(warnings).each { |message| runtime_output(message) }
       end
 
       def load_prompt_interface
@@ -67,6 +92,24 @@ module Kward
         @prompt.respond_to?(:start_stream_block) && @prompt.respond_to?(:write_delta)
       end
 
+      def emit_warning(message)
+        sink = ConfigFiles.warning_sink
+        sink ? sink.call(message) : warn(message)
+      end
+
+      def clear_interactive_warning_sink
+        ConfigFiles.warning_sink = nil
+        @interactive_warning_sink_active = false
+        @pending_interactive_warnings = nil
+        @interactive_warning_sink = nil
+      end
+
+      def update_prompt_workspace_root(root)
+        return unless @prompt.respond_to?(:update_workspace_root)
+
+        @prompt.update_workspace_root(root, prompt_history: PromptHistory.new(cwd: root))
+      end
+
       # Writes the startup info screen output for the terminal CLI flow.
       def print_visual_banner
         return unless @prompt.respond_to?(:print_visual_banner)
@@ -172,7 +215,7 @@ module Kward
           context = plugin_context(current_footer_conversation, "")
           renderer.call(context).to_s
         rescue StandardError => e
-          warn "Warning: Kward plugin footer error: #{e.message}"
+          emit_warning "Warning: Kward plugin footer error: #{e.message}"
           ""
         end
       end

data/lib/kward/cli/rendering.rb

@@ -272,8 +272,12 @@ module Kward
       # Writes the block delta output for the terminal CLI flow.
       def print_block_delta(label, delta)
         if prompt_interface?
-          @prompt.start_stream_block(label)
-          @prompt.write_delta(delta)
+          if @prompt.respond_to?(:write_stream_block)
+            @prompt.write_stream_block(label, delta, finish: false)
+          else
+            @prompt.start_stream_block(label)
+            @prompt.write_delta(delta)
+          end
         else
           start_stream_block(label)
           print delta

data/lib/kward/cli/runtime_helpers.rb

@@ -60,6 +60,7 @@ module Kward
           client: @client,
           tool_registry: tool_registry,
           conversation: conversation,
+          warning_sink: ConfigFiles.warning_sink,
           hook_manager: hook_manager,
           hook_context: hook_context
         )
@@ -317,8 +318,8 @@ module Kward
         @pending_inputs&.first.is_a?(Hash) && @pending_inputs.first[:tab_action]
       end
 
-      def configured_workspace(root: current_workspace_root)
-        WorkspaceFactory.build(root: root, guardrails: workspace_guardrails_enabled?, config: safely_read_config.to_h)
+      def configured_workspace(root: current_workspace_root, strict: false)
+        WorkspaceFactory.build(root: root, guardrails: workspace_guardrails_enabled?, config: safely_read_config.to_h, strict: strict)
       end
 
       def workspace_guardrails_enabled?
@@ -401,6 +402,8 @@ module Kward
       end
 
       def current_workspace_root
+        conversation = active_tab&.agent&.conversation if respond_to?(:active_tab, true)
+        return conversation.workspace_root if conversation&.respond_to?(:workspace_root)
         return @active_session.cwd.to_s unless @active_session&.cwd.to_s.empty?
         return @working_directory if @working_directory
 

data/lib/kward/cli/sessions.rb

@@ -103,7 +103,7 @@ module Kward
         @active_session = track_session(session_store.create)
         reset_session_diff
         cleanup_replaced_session(previous_session)
-        conversation = new_conversation(workspace_root: session_store.cwd)
+        conversation = new_conversation(workspace_root: current_workspace_root)
         @active_session.attach(conversation)
         run_lifecycle_hook("session_create", conversation: conversation, payload: { action: "create" })
         update_assistant_prompt(conversation)

data/lib/kward/cli/settings.rb

@@ -120,7 +120,10 @@ module Kward
 
       def provider_choices
         current = current_model_provider
-        ["Codex", "Anthropic", "OpenRouter", "Copilot", "Local"].map do |provider|
+        configured_api_key_providers = ProviderCatalog.api_key_providers.filter_map do |provider|
+          provider.name if api_key_store.configured?(provider.id)
+        end
+        (["Codex", "Anthropic", "OpenRouter", "Copilot", "Local"] + configured_api_key_providers).uniq.map do |provider|
           label = provider.dup
           label += " (current)" if provider == current
           label
@@ -135,7 +138,7 @@ module Kward
         return "Copilot" if text.start_with?("copilot")
         return "Local" if text.start_with?("local")
 
-        nil
+        ProviderCatalog.find_by_name(selected)&.name
       end
 
       def configure_local_server_preset(conversation)
@@ -721,12 +724,15 @@ module Kward
           return
         end
 
-        selected = @prompt.select("OAuth provider", login_provider_choices, title: "Login")
+        method = selected_login_method(@prompt.select("How would you like to connect?", login_method_choices, title: "Login"))
+        return unless method
+
+        selected = @prompt.select(login_provider_prompt(method), login_provider_choices(method), title: "Login")
         provider = selected_login_provider(selected)
         return unless provider
 
         run_busy_local_command_and_requeue(activity: "running") do
-          login(provider: provider)
+          login(provider: provider, auth_method: method)
           reload_client_config
         end
       rescue StandardError => e
@@ -740,17 +746,40 @@ module Kward
         end
 
         models ||= normalized_available_models(conversation)
-        choices = model_choices(models, conversation)
-        selected = @prompt.select("Default model", choices, title: "Models", custom: true)
-        return unless selected
-
-        provider, model = selected_model(selected, models)
-        raise "Model must be a non-empty string" if model.to_s.strip.empty?
-
-        ConfigFiles.update_config(ModelInfo.config_values_for_selection(provider, model))
-        reload_client_config
-        refresh_conversation_runtime(conversation)
-        @prompt.redraw if @prompt.respond_to?(:redraw)
+        provider_filter = nil
+        show_all = false
+        loop do
+          visible_models = provider_filter ? models.select { |model| model[:provider] == provider_filter } : models
+          visible_models = visible_models.select { |model| default_selectable_model?(model) } unless show_all
+          actions = ["Refresh model list", "Enter model ID manually", "Show all models", "Change provider"]
+          selected = @prompt.select("Default model", model_choices(visible_models, conversation) + actions, title: "Models", custom: true)
+          return unless selected
+
+          case selected.to_s
+          when "Refresh model list"
+            refreshed = @client.refresh_available_models(provider: provider_filter) if @client.respond_to?(:refresh_available_models)
+            models = normalized_available_models(conversation, models: refreshed)
+          when "Enter model ID manually"
+            provider = provider_filter || conversation&.provider || current_model_provider
+            model = @prompt.select("Model ID for #{provider}", [], title: "Models", custom: true)
+            return unless model
+            persist_model_selection(provider, model, conversation)
+            return
+          when "Show all models"
+            provider_filter = nil
+            show_all = true
+          when "Change provider"
+            selected_provider_name = selected_provider(@prompt.select("Provider", provider_choices, title: "Models"))
+            if selected_provider_name
+              provider_filter = selected_provider_name
+              show_all = false
+            end
+          else
+            provider, model = selected_model(selected, models)
+            persist_model_selection(provider, model, conversation)
+            return
+          end
+        end
       rescue StandardError => e
         runtime_output("Model error: #{e.message}")
       end
@@ -784,23 +813,38 @@ module Kward
         @prompt.respond_to?(:select)
       end
 
-      def login_provider_choices
-        ["OpenAI", "Anthropic", "OpenRouter", "GitHub"]
+      def login_method_choices
+        ["API key", "Subscription / OAuth"]
       end
 
-      def selected_login_provider(selected)
+      def selected_login_method(selected)
         case selected.to_s.downcase
-        when /\Aopenai\b/
-          "openai"
-        when /\Aanthropic\b/, /\Aclaude\b/
-          "anthropic"
-        when /\Aopenrouter\b/
-          "openrouter"
-        when /\Agithub\b/
-          "github"
+        when /\Aapi key\z/ then :api_key
+        when /\Asubscription \/ oauth\z/ then :oauth
+        end
+      end
+
+      def login_provider_prompt(method)
+        method == :api_key ? "Add an API key" : "Sign in with a subscription"
+      end
+
+      def login_provider_choices(method)
+        if method == :api_key
+          ProviderCatalog.api_key_providers.map(&:name)
+        else
+          ["Anthropic Claude", "ChatGPT", "GitHub Copilot"]
         end
       end
 
+      def selected_login_provider(selected)
+        value = selected.to_s.downcase
+        return "openai" if value == "openai" || value == "chatgpt"
+        return "anthropic" if value == "anthropic" || value == "anthropic claude"
+        return "copilot" if value == "github copilot"
+
+        ProviderCatalog.find_by_name(selected)&.id
+      end
+
       def model_overlay_available?
         @prompt.respond_to?(:select)
       end
@@ -822,11 +866,11 @@ module Kward
         values.find { |value| choice.to_s.downcase.start_with?(value) }
       end
 
-      def normalized_available_models(conversation = current_footer_conversation)
+      def normalized_available_models(conversation = current_footer_conversation, models: nil)
         current_provider = conversation.provider || (@client.respond_to?(:current_provider) ? @client.current_provider : "Codex")
         current_model = conversation.model || (@client.respond_to?(:current_model) ? @client.current_model : nil)
         current_reasoning = conversation.reasoning_effort || (@client.respond_to?(:current_reasoning_effort) ? @client.current_reasoning_effort : nil)
-        models = @client.respond_to?(:available_models) ? @client.available_models : []
+        models ||= @client.respond_to?(:available_models) ? @client.available_models : []
         ModelInfo.normalize_available(
           models,
           current_provider: current_provider,
@@ -846,17 +890,37 @@ module Kward
         choices.empty? ? ["#{current_provider} #{current_model} (current)"] : choices.uniq
       end
 
+      def default_selectable_model?(model)
+        return true if model[:current]
+
+        capabilities = Array(model[:supportedParameters]).map { |value| value.to_s.downcase }
+        return true if capabilities.empty?
+
+        capabilities.any? do |capability|
+          ["tools", "toolchoice", "functioncalling", "generatecontent", "streamgeneratecontent"].include?(capability.delete("_-"))
+        end
+      end
+
       def selected_model(selected, models)
         text = selected.to_s.sub(/ \(current\)\z/, "").strip
         known = models.find { |model| "#{model[:provider]} #{model[:id]}" == text }
         return [known[:provider], known[:id]] if known
 
         provider, model = text.split(/\s+/, 2)
-        if ["Codex", "Anthropic", "OpenRouter", "Copilot"].include?(provider) && !model.to_s.strip.empty?
-          [provider, model.strip]
-        else
-          [current_model_provider, text]
-        end
+        known_provider = ["Codex", "Anthropic", "OpenRouter", "Copilot", "Local"].include?(provider) || ProviderCatalog.find_by_name(provider)
+        return [provider, model.strip] if known_provider && !model.to_s.strip.empty?
+
+        [current_model_provider, text]
+      end
+
+      def persist_model_selection(provider, model, conversation)
+        model = model.to_s.strip
+        raise "Model must be a non-empty string" if model.empty?
+
+        ConfigFiles.update_config(ModelInfo.config_values_for_selection(provider, model))
+        reload_client_config
+        refresh_conversation_runtime(conversation)
+        @prompt.redraw if @prompt.respond_to?(:redraw)
       end
 
       REASONING_CONFIG_DEBOUNCE_SECONDS = 0.5

data/lib/kward/cli/slash_commands.rb

@@ -345,7 +345,7 @@ module Kward
         percent = ((reserve_tokens.to_f / context_window.to_i) * 100).round(1)
         "Auto-compaction reserve: #{reserve_tokens} tokens (#{percent}% of #{context_window})"
       rescue StandardError => e
-        warn "Auto-compaction status unavailable: #{e.message}"
+        emit_warning "Auto-compaction status unavailable: #{e.message}"
         nil
       end