kward 0.78.0 → 0.80.0

data/lib/kward/cli/worktrees.rb

@@ -0,0 +1,360 @@
+require "securerandom"
+
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Coordinates Git worktree bindings with session-backed tab runtimes.
+  class CLI
+    module Worktrees
+      private
+
+      def git_worktree_manager
+        @git_worktree_manager ||= GitWorktreeManager.new
+      end
+
+      def worktree_binding_for(tab)
+        driver = tab&.driver
+        driver.worktree if driver&.respond_to?(:worktree)
+      end
+
+      def worktree_root_for(binding, fallback: current_workspace_root)
+        return fallback unless binding
+
+        binding.active? ? binding.path : binding.origin_root
+      end
+
+      def reconcile_worktree_binding(tab, conversation)
+        binding = worktree_binding_for(tab)
+        return nil unless binding
+        return binding unless binding.active?
+
+        binding.active = false unless File.realpath(conversation.workspace_root) == File.realpath(binding.path)
+        binding
+      rescue Errno::ENOENT, Errno::ENOTDIR
+        binding.active = false
+        binding
+      end
+
+      def validate_worktree_binding!(binding)
+        return unless binding
+
+        unless File.directory?(binding.origin_root)
+          raise GitWorktreeManager::Error, "Original workspace is unavailable: #{binding.origin_root}"
+        end
+
+        return unless binding.active?
+
+        info = git_worktree_manager.inspect(repository_root: binding.repository_root, path: binding.path)
+        return if info.branch == binding.branch
+
+        raise GitWorktreeManager::Error, "Worktree branch changed: expected #{binding.branch}, found #{info.branch || "detached HEAD"}"
+      end
+
+      def rebind_session_tab(tab, root:, worktree:)
+        raise GitWorktreeManager::Error, "A session tab is required." unless tab&.session
+        raise GitWorktreeManager::Error, "The session store is unavailable." unless @session_store
+
+        session, conversation = @session_store.load(
+          tab.session.path,
+          workspace: configured_workspace(root: root, strict: worktree&.active? == true),
+          provider: current_model_provider,
+          model: current_model_id,
+          reasoning_effort: current_reasoning_effort
+        )
+        agent = build_tab_agent(conversation, session, worktree: worktree)
+        tab.session = track_session(session)
+        tab.agent = agent
+        tab.driver = SessionTabDriver.new(session: tab.session, agent: agent, worktree: worktree)
+        tab.diff = SessionDiff.from_session_file(tab.session.path)
+        tab.status = "idle"
+        tab.thread = nil
+        tab.cancellation = nil
+        tab.steering = nil
+        tab.error = nil
+        tab.answer = nil
+        tab.pending_question = nil
+        tab.unread = false
+        tab.error_reported = false
+        tab.event_history.clear
+        tab.seen_events = 0
+        tab.queued_inputs.clear
+        tab.shell = nil
+        tab.stream_state = new_tab_stream_state(tab.driver)
+        tab.markdown_chunks.clear
+        assign_tab_question_prompt(tab.agent, tab)
+        if tab == active_tab
+          @active_session = tab.session
+          @session_diff = tab.diff
+          update_assistant_prompt(tab.agent.conversation)
+        end
+        tab
+      end
+
+      def handle_worktree_command(argument)
+        case argument.to_s.strip
+        when "", "activate"
+          activate_active_tab_worktree
+        when "detach"
+          detach_current_worktree
+        when "status"
+          print_active_worktree_status
+        when "remove"
+          remove_active_worktree
+        when "merge"
+          merge_active_worktree
+        when "merge abort"
+          abort_active_worktree_merge
+        else
+          runtime_output("Usage: /tab worktree [activate|detach|status|merge|merge abort|remove]")
+        end
+      end
+
+      def activate_active_tab_worktree
+        tab = active_tab
+        return runtime_output("There is no active tab.") unless tab
+        return runtime_output("Worktrees are available only for normal session tabs.") if plugin_tab?(tab)
+        return runtime_output("Tab #{active_tab_number} is running and cannot change workspaces yet.") if tab&.running? || tab&.local_busy? || tab&.shell
+
+        binding = worktree_binding_for(tab)
+        return runtime_output("Tab #{active_tab_number} is already using #{binding.branch} at #{binding.path}.") if binding&.active?
+        return activate_existing_worktree(tab, binding) if binding
+
+        attach_new_worktree(tab)
+      rescue GitWorktreeManager::Error, Sandbox::UnavailableError => e
+        runtime_output("Worktree error: #{e.message}")
+      end
+
+      def detach_current_worktree
+        tab = active_tab
+        binding = worktree_binding_for(tab)
+        return runtime_output("Tab #{active_tab_number} has no worktree binding.") unless binding
+        return runtime_output("Tab #{active_tab_number} is not using its linked worktree.") unless binding.active?
+        return runtime_output("Tab #{active_tab_number} is running and cannot change workspaces yet.") if tab.running? || tab.local_busy? || tab.shell
+
+        detach_active_worktree(tab, binding)
+      rescue GitWorktreeManager::Error, Sandbox::UnavailableError => e
+        runtime_output("Worktree error: #{e.message}")
+      end
+
+      def attach_new_worktree(tab)
+        origin_root = tab.agent.conversation.workspace_root
+        repository_root = git_worktree_manager.repository_root(origin_root)
+        status = git_worktree_manager.status(origin_root)
+        if status.dirty? && !confirm_worktree_action(<<~MESSAGE)
+          #{origin_root} has #{status.entries.length} local change(s).
+
+          The new worktree will be created from HEAD. Existing changes will remain in the original workspace and will not be copied.
+
+          Create the worktree anyway?
+        MESSAGE
+          return
+        end
+
+        branch = generated_worktree_branch(tab)
+        path = default_worktree_path(repository_root, branch)
+        binding = git_worktree_manager.create(
+          repository_root: repository_root,
+          origin_root: origin_root,
+          path: path,
+          branch: branch
+        )
+        begin
+          rebind_active_tab(tab, root: binding.path, worktree: binding)
+        rescue StandardError
+          git_worktree_manager.remove(repository_root: binding.repository_root, path: binding.path)
+          raise
+        end
+        runtime_output("Tab #{active_tab_number} is now using #{binding.branch} at #{binding.path}.")
+      end
+
+      def activate_existing_worktree(tab, binding)
+        binding.active = true
+        validate_worktree_binding!(binding)
+        rebind_active_tab(tab, root: binding.path, worktree: binding)
+        runtime_output("Tab #{active_tab_number} is now using #{binding.branch} at #{binding.path}.")
+      rescue StandardError
+        binding.active = false
+        raise
+      end
+
+      def detach_active_worktree(tab, binding)
+        validate_worktree_binding!(binding)
+        status = git_worktree_manager.status(binding.path)
+        if status.dirty? && !confirm_worktree_action(<<~MESSAGE)
+          #{binding.path} has #{status.entries.length} local change(s).
+
+          They will remain in the worktree after this tab switches back to #{binding.origin_root}.
+
+          Detach and keep the worktree?
+        MESSAGE
+          return
+        end
+
+        binding.active = false
+        rebind_active_tab(tab, root: binding.origin_root, worktree: binding)
+        runtime_output("Tab #{active_tab_number} returned to #{binding.origin_root}; worktree kept at #{binding.path}.")
+      rescue StandardError
+        binding.active = true
+        raise
+      end
+
+      def rebind_active_tab(tab, root:, worktree:)
+        save_active_tab_state
+        stop_tab_live_view
+        rebind_session_tab(tab, root: root, worktree: worktree)
+        activate_tab(@active_tab_index)
+        persist_tabs
+      end
+
+      def print_active_worktree_status
+        tab = active_tab
+        binding = worktree_binding_for(tab)
+        return runtime_output("Tab #{active_tab_number} has no worktree binding.") unless binding
+
+        lines = [
+          "Worktree: #{binding.active? ? "active" : "detached"}",
+          "Origin: #{binding.origin_root}",
+          "Path: #{binding.path}",
+          "Branch: #{binding.branch}",
+          "Base: #{binding.base_revision}"
+        ]
+        begin
+          info = git_worktree_manager.inspect(repository_root: binding.repository_root, path: binding.path)
+          raise GitWorktreeManager::Error, "Worktree branch changed: expected #{binding.branch}, found #{info.branch || "detached HEAD"}" unless info.branch == binding.branch
+          status = git_worktree_manager.status(binding.path)
+          lines << "Changes: #{status.clean? ? "clean" : "#{status.entries.length} local change(s)"}"
+        rescue GitWorktreeManager::Error => e
+          lines << "State: unavailable (#{e.message})"
+        end
+        runtime_output(lines.join("\n"))
+      end
+
+      def merge_active_worktree
+        tab = active_tab
+        binding = worktree_binding_for(tab)
+        return runtime_output("Tab #{active_tab_number} has no worktree binding.") unless binding
+        return runtime_output("Tab #{active_tab_number} is running and cannot merge its worktree yet.") if tab.running? || tab.local_busy? || tab.shell
+        return runtime_output("Activate the worktree before merging it.") unless binding.active?
+
+        validate_worktree_binding!(binding)
+        source_status = git_worktree_manager.status(binding.path)
+        return runtime_output("Worktree has local changes; commit or clean it before merging.") if source_status.dirty?
+
+        target_status = git_worktree_manager.status(binding.origin_root)
+        return runtime_output("Original workspace has local changes; clean it before merging.") if target_status.dirty?
+
+        target_branch = git_worktree_manager.current_branch(binding.origin_root)
+        return runtime_output("Original workspace is in detached HEAD state; select a target branch before merging.") if target_branch.empty?
+        return runtime_output("Worktree already uses the target branch #{target_branch}.") if target_branch == binding.branch
+
+        target_revision = git_worktree_manager.current_revision(binding.origin_root)
+        source_revision = git_worktree_manager.current_revision(binding.path)
+        return unless confirm_worktree_action(<<~MESSAGE)
+          Merge #{binding.branch} into #{target_branch}?
+
+          Source: #{binding.branch} (#{source_revision})
+          Target: #{target_branch} (#{target_revision})
+          Original workspace: #{binding.origin_root}
+
+          The merge runs directly in the original workspace.
+        MESSAGE
+
+        unless git_worktree_manager.current_revision(binding.origin_root) == target_revision && git_worktree_manager.status(binding.origin_root).clean?
+          return runtime_output("Original workspace changed before the merge could begin; review it and try again.")
+        end
+
+        result = git_worktree_manager.merge(
+          repository_root: binding.repository_root,
+          target_path: binding.origin_root,
+          source_branch: binding.branch
+        )
+        if result.merged?
+          runtime_output("Merged #{binding.branch} into #{target_branch}.")
+        else
+          runtime_output("Merge conflicts in #{result.conflicts.join(", ")}. Resolve them in #{binding.origin_root} or run /tab worktree merge abort.")
+        end
+      rescue GitWorktreeManager::Error => e
+        runtime_output("Worktree error: #{e.message}")
+      end
+
+      def abort_active_worktree_merge
+        tab = active_tab
+        binding = worktree_binding_for(tab)
+        return runtime_output("Tab #{active_tab_number} has no worktree binding.") unless binding
+        return runtime_output("Tab #{active_tab_number} is running and cannot abort its merge yet.") if tab.running? || tab.local_busy? || tab.shell
+        return runtime_output("No merge is in progress in the original workspace.") unless git_worktree_manager.merge_in_progress?(binding.origin_root)
+        return unless confirm_worktree_action("Abort the merge in #{binding.origin_root}?")
+
+        git_worktree_manager.abort_merge(binding.origin_root)
+        runtime_output("Aborted the merge in #{binding.origin_root}.")
+      rescue GitWorktreeManager::Error => e
+        runtime_output("Worktree error: #{e.message}")
+      end
+
+      def remove_active_worktree
+        tab = active_tab
+        binding = worktree_binding_for(tab)
+        return runtime_output("Tab #{active_tab_number} has no worktree binding.") unless binding
+        return runtime_output("Tab #{active_tab_number} is running and cannot remove its worktree yet.") if tab.running? || tab.local_busy? || tab.shell
+
+        git_worktree_manager.inspect(repository_root: binding.repository_root, path: binding.path)
+        status = git_worktree_manager.status(binding.path)
+        return runtime_output("Worktree has local changes; detach it or clean it before removing it.") if status.dirty?
+
+        was_active = binding.active?
+        detached = false
+        if was_active
+          binding.active = false
+          rebind_active_tab(tab, root: binding.origin_root, worktree: binding)
+          detached = true
+        end
+        git_worktree_manager.remove(repository_root: binding.repository_root, path: binding.path)
+        tab.driver = SessionTabDriver.new(session: tab.session, agent: tab.agent)
+        tab.stream_state = new_tab_stream_state(tab.driver)
+        persist_tabs
+        runtime_output("Removed worktree #{binding.path}. Branch #{binding.branch} was kept.")
+      rescue GitWorktreeManager::Error => e
+        binding.active = true if was_active && !detached
+        runtime_output("Worktree error: #{e.message}")
+      end
+
+      def confirm_worktree_action(message)
+        prompt = message.to_s.strip
+        if @prompt.respond_to?(:ask_user_question)
+          answer = @prompt.ask_user_question([{
+            header: "Confirm worktree action",
+            question: prompt,
+            options: [
+              { label: "Continue", description: "Proceed with this Git operation." },
+              { label: "Cancel", description: "Leave the workspace unchanged." }
+            ]
+          }])
+          return answer&.first&.fetch(:answer, nil) == "Continue"
+        end
+
+        return false unless @prompt.respond_to?(:yes?)
+
+        runtime_output(prompt) if prompt.include?("\n")
+        @prompt.yes?(prompt.include?("\n") ? "Continue?" : prompt, default: false)
+      end
+
+      def generated_worktree_branch(tab)
+        label = tab.label.to_s.downcase.gsub(/[^a-z0-9]+/, "-").sub(/\A-+|-+\z/, "")
+        label = "tab-#{active_tab_number}" if label.empty?
+        "kward/#{label}-#{SecureRandom.hex(3)}"
+      end
+
+      def default_worktree_path(repository_root, branch)
+        slug = branch.to_s.delete_prefix("kward/").gsub(/[^a-zA-Z0-9._-]+/, "-")
+        File.join(File.dirname(repository_root), ".kward-worktrees", File.basename(repository_root), slug)
+      end
+
+      def unavailable_worktree_tab(descriptor, error, label: nil)
+        driver = UnavailableTabDriver.new(
+          descriptor: descriptor,
+          message: "Worktree unavailable: #{error.message}"
+        )
+        build_tab(nil, nil, driver: driver, label: label || descriptor["label"] || "Worktree")
+      end
+    end
+  end
+end

data/lib/kward/cli.rb

@@ -17,6 +17,7 @@ require_relative "export_path"
 require_relative "ekwsh"
 require_relative "interactive_pty_runner"
 require_relative "auth/anthropic_oauth"
+require_relative "auth/api_key_store"
 require_relative "auth/github_oauth"
 require_relative "auth/openrouter_api_key"
 require_relative "image_attachments"
@@ -25,12 +26,16 @@ require_relative "memory/turn_context"
 require_relative "transcript_export"
 require_relative "message_access"
 require_relative "model/model_info"
+require_relative "model/azure_openai_config"
+require_relative "model/provider_catalog"
+require_relative "model/catalog"
 require_relative "auth/openai_oauth"
 require_relative "pan/server"
 require_relative "plugin_registry"
 require_relative "prompts/commands"
 require_relative "model/retry_message"
 require_relative "rpc/server"
+require_relative "transport/runtime"
 require_relative "session_diff"
 require_relative "session_store"
 require_relative "session_naming"
@@ -38,13 +43,15 @@ require_relative "tab_store"
 require_relative "tab_driver"
 require_relative "session_trash"
 require_relative "session_tree_renderer"
+require_relative "skills/capture"
 require_relative "starter_pack_installer"
 require_relative "steering"
 require_relative "update_check"
 require_relative "tools/tool_call"
 require_relative "tools/registry"
 require_relative "telemetry/stats"
-require_relative "workspace"
+require_relative "workspace_factory"
+require_relative "git_worktree_manager"
 require_relative "cli/commands"
 require_relative "cli/auth_commands"
 require_relative "cli/doctor"
@@ -58,6 +65,7 @@ require_relative "cli/hook_commands"
 require_relative "cli/settings"
 require_relative "cli/sessions"
 require_relative "cli/tabs"
+require_relative "cli/worktrees"
 require_relative "cli/compaction"
 require_relative "cli/rendering"
 require_relative "cli/prompt_interface"
@@ -65,6 +73,7 @@ require_relative "cli/plugins"
 require_relative "cli/git"
 require_relative "cli/interactive_turn"
 require_relative "cli/tool_summaries"
+require_relative "cli/transports"
 
 # Namespace for the Kward CLI agent runtime.
 module Kward
@@ -91,6 +100,7 @@ module Kward
     include CLI::Settings
     include CLI::Sessions
     include CLI::Tabs
+    include CLI::Worktrees
     include CLI::CompactionCommands
     include CLI::Rendering
     include CLI::PromptInterfaceSupport
@@ -98,6 +108,7 @@ module Kward
     include CLI::GitCommands
     include CLI::InteractiveTurn
     include CLI::ToolSummaries
+    include CLI::Transports
 
     def initialize(argv: ARGV, stdin: STDIN, prompt: TTY::Prompt.new, client: nil, session_store: nil, context_usage: ContextUsage.new)
       @argv = argv
@@ -243,6 +254,16 @@ module Kward
         return
       end
 
+      if @argv.first == "transport"
+        if help_option_arguments?(@argv[1..] || [])
+          print_command_help("transport")
+          return
+        end
+
+        handle_transport_command(@argv[1..] || [])
+        return
+      end
+
       if @argv.first == "rpc"
         if help_option_arguments?(@argv[1..] || [])
           print_command_help("rpc")

data/lib/kward/config_files.rb

@@ -3,9 +3,11 @@ require "fileutils"
 require "json"
 require "yaml"
 require_relative "frontmatter"
+require_relative "deep_copy"
 require_relative "private_file"
 require_relative "path_guard"
 require_relative "permissions/policy"
+require_relative "sandbox/policy"
 require_relative "ekwsh"
 require_relative "editor_mode"
 require_relative "diff_view_mode"
@@ -151,13 +153,23 @@ module Kward
           "trust_project" => false
         },
         "enforce_workspace_agents_file" => false,
+        "system_prompt" => {
+          "include_principles" => true
+        },
         "mcpServers" => {},
+        "transports" => {},
         "tools" => {
           "workspace_guardrails" => true
         },
         "permissions" => {
           "enabled" => false,
           "mode" => "ask"
+        },
+        "sandbox" => {
+          "mode" => "off",
+          "network" => "deny",
+          "writable_roots" => [],
+          "protect_git_metadata" => true
         }
       }
     end
@@ -180,6 +192,13 @@ module Kward
       File.join(cache_dir, "openrouter_models.json")
     end
 
+    def model_catalog_cache_path(provider_id)
+      provider = provider_id.to_s.gsub(/[^a-z0-9_-]/i, "_")
+      raise ArgumentError, "Provider id must be a non-empty string" if provider.empty?
+
+      File.join(cache_dir, "models", "#{provider}.json")
+    end
+
     def update_check_cache_path
       File.join(cache_dir, "update_check.json")
     end
@@ -226,7 +245,10 @@ module Kward
       return {} if skip_config? && path == config_path
       return {} unless File.exist?(path)
 
-      JSON.parse(File.read(path))
+      config = JSON.parse(File.read(path))
+      return config if config.is_a?(Hash)
+
+      raise ConfigError.new(path: path, format: "JSON", detail: "top-level value must be an object")
     rescue JSON::ParserError => e
       raise ConfigError.new(path: path, format: "JSON", detail: e.message)
     end
@@ -498,6 +520,18 @@ module Kward
       Permissions::Policy.from_config(config)
     end
 
+    # Builds the user-controlled command sandbox policy for a workspace.
+    def sandbox_policy(workspace_root, config = read_config)
+      sandbox = config["sandbox"].is_a?(Hash) ? config["sandbox"] : {}
+      Sandbox::Policy.new(
+        mode: sandbox.fetch("mode", "off"),
+        network: sandbox.fetch("network", "deny"),
+        workspace_root: workspace_root,
+        writable_roots: sandbox.fetch("writable_roots", []),
+        protect_git_metadata: sandbox.fetch("protect_git_metadata", true)
+      )
+    end
+
     # Returns whether project-level Agent Skills should be loaded from the workspace.
     def project_skills_trusted?(config = read_config)
       skills = config["skills"].is_a?(Hash) ? config["skills"] : {}
@@ -522,6 +556,15 @@ module Kward
       value.is_a?(Hash) ? value : {}
     end
 
+    # Returns the private configuration namespace for one transport.
+    def transport_config(transport_id, config = read_config)
+      transports = config["transports"]
+      return {} unless transports.is_a?(Hash)
+
+      values = transports[transport_id.to_s]
+      values.is_a?(Hash) ? DeepCopy.dup(values) : {}
+    end
+
     # Returns configured MCP stdio servers, or an empty config when absent.
     def mcp_servers(config = read_config)
       value = config["mcpServers"] || config.dig("mcp", "servers")
@@ -558,13 +601,61 @@ module Kward
     # alias for existing installations.
     #
     # @return [String, nil] prompt text, or nil when absent/too large
-    def agents_prompt
+    def agents_prompt(config: read_config)
+      return nil unless include_config_principles?(config)
+
       path = config_principles_path
       return read_prompt_file(path, "Kward principles file") if File.exist?(path)
 
       read_prompt_file(config_agents_path, "Kward AGENTS.md alias")
     end
 
+    # Returns whether config-directory principles are included in normal system
+    # prompt assembly. Replacement prompt files bypass all assembled sections.
+    def include_config_principles?(config = read_config)
+      settings = config["system_prompt"]
+      return true unless settings.is_a?(Hash)
+
+      settings["include_principles"] != false
+    end
+
+    # Returns the configured replacement system prompt path, or nil when normal
+    # prompt assembly should be used. Relative paths are anchored to the config
+    # directory so configuration remains portable with KWARD_CONFIG_PATH.
+    def system_prompt_file_path(config = read_config)
+      settings = config["system_prompt"]
+      value = settings.is_a?(Hash) ? settings["file"].to_s.strip : ""
+      return nil if value.empty?
+
+      File.expand_path(value, config_dir)
+    end
+
+    # Returns the replacement system prompt text when configured. A configured
+    # but unavailable file intentionally yields nil: callers must not fall back
+    # to Kward's larger assembled prompt in replacement mode.
+    def system_prompt_file(config = read_config)
+      path = system_prompt_file_path(config)
+      return nil unless path
+
+      read_prompt_file(path, "custom system prompt file")
+    end
+
+    def replacement_system_prompt?(config = read_config)
+      !system_prompt_file_path(config).nil?
+    end
+
+    # Returns a lightweight fingerprint for config-owned prompt sources. It is
+    # used by active conversations to pick up prompt edits without a restart.
+    def system_prompt_sources_fingerprint
+      config = read_config
+      paths = [config_path, system_prompt_file_path(config)]
+      if include_config_principles?(config)
+        paths << (File.exist?(config_principles_path) ? config_principles_path : config_agents_path)
+      end
+
+      paths.compact.map { |path| prompt_source_signature(path) }.join("\0")
+    end
+
     def config_principles_path
       File.join(config_dir, "PRINCIPLES.md")
     end
@@ -686,6 +777,15 @@ module Kward
       read_prompt_file(workspace_agents_path(workspace_root), "workspace AGENTS.md")
     end
 
+    def prompt_source_signature(path)
+      return "#{path}:missing" unless File.exist?(path)
+
+      stat = File.stat(path)
+      "#{path}:#{stat.size}:#{stat.mtime.to_f}"
+    rescue StandardError
+      "#{path}:unavailable"
+    end
+
     def read_prompt_file(path, label)
       return nil unless File.exist?(path)
 
@@ -817,7 +917,7 @@ module Kward
       File.expand_path("~/.kward/plugins")
     end
 
-    # Finds trusted top-level plugin files.
+    # Finds trusted plugin files and package entrypoints.
     #
     # Plugins are intentionally loaded only from `~/.kward/plugins`, not from a
     # workspace or custom `KWARD_CONFIG_PATH` directory.
@@ -827,7 +927,9 @@ module Kward
       plugins_root = plugin_dir
       return [] unless Dir.exist?(plugins_root)
 
-      Dir.glob(File.join(plugins_root, "*.rb")).sort
+      paths = Dir.glob(File.join(plugins_root, "*.rb"))
+      paths.concat(Dir.glob(File.join(plugins_root, "*", "plugin.rb")))
+      paths.sort
     rescue StandardError => e
       warn "Warning: skipping Kward plugins in #{plugins_root}: #{e.message}"
       []