kward 0.76.0 → 0.77.0

data/lib/kward/pan/server.rb

@@ -13,22 +13,28 @@ require_relative "../plugin_registry"
 require_relative "../prompts/commands"
 require_relative "../rpc/transcript_normalizer"
 require_relative "../session_store"
+require_relative "../session_trash"
 require_relative "../tools/tool_call"
 require_relative "../tools/registry"
+require_relative "../version"
 require_relative "../workspace"
 
 # Namespace for the Kward CLI agent runtime.
 module Kward
-  # Minimal local HTTP server for the experimental Pan web UI.
+  # Local HTTP server for the mobile-friendly Pan web UI.
   class PanServer
     DEFAULT_HOST = "0.0.0.0"
     DEFAULT_PORT = 8765
     MAX_REQUEST_BODY_BYTES = 64 * 1024
+    ROUTING_PROBE_ADDRESS = "8.8.8.8"
+    ROUTING_PROBE_PORT = 80
 
-    def initialize(client:, working_directory:, config: ConfigFiles.read_config, config_dir: ConfigFiles.config_dir, output: $stderr)
+    def initialize(client:, working_directory:, config: ConfigFiles.read_config, config_dir: ConfigFiles.config_dir, output: $stderr, udp_socket_class: UDPSocket)
       @client = client
       @output = output
+      @udp_socket_class = udp_socket_class
       @workspace = Workspace.new(root: working_directory)
+      @full_config = config
       @config = pan_config(config)
       @host = @config.fetch("host", DEFAULT_HOST).to_s
       @port = positive_port(@config.fetch("port", DEFAULT_PORT))
@@ -37,28 +43,22 @@ module Kward
       raise "Pan mode requires pan_mode.username and pan_mode.password in #{ConfigFiles.config_path}" if @username.empty? || @password.empty?
 
       @session_store = SessionStore.new(config_dir: config_dir, cwd: @workspace.root.to_s)
-      @session = @session_store.create
-      @conversation = Conversation.new(
-        workspace_root: @workspace.root.to_s,
+      @session = @session_store.create(
+        provider: (@client.current_provider if @client.respond_to?(:current_provider)),
         model: (@client.current_model if @client.respond_to?(:current_model)),
         reasoning_effort: (@client.current_reasoning_effort if @client.respond_to?(:current_reasoning_effort))
       )
+      @conversation = new_conversation
       @session.attach(@conversation)
-      hook_context = lifecycle_hook_context
-      hook_manager = lifecycle_hook_manager
-      @agent = Agent.new(
-        client: @client,
-        tool_registry: ToolRegistry.new(workspace: @workspace, ask_user_question_enabled: false, hook_manager: hook_manager, hook_context: hook_context),
-        conversation: @conversation,
-        hook_manager: hook_manager,
-        hook_context: hook_context
-      )
+      @agent = build_agent
       @prompt_queue = Queue.new
       @subscribers = []
       @subscribers_mutex = Mutex.new
       @worker_started = false
       @active = false
+      @pending_turns = 0
       @state_mutex = Mutex.new
+      @session_mutex = Mutex.new
     end
 
     attr_reader :host, :port, :session, :workspace
@@ -91,8 +91,11 @@ module Kward
       text = prompt.to_s
       return { ok: false, error: "Prompt is required" } if text.strip.empty?
 
-      queued_at = Time.now.utc.iso8601(3)
-      @prompt_queue << { prompt: text, queued_at: queued_at }
+      @session_mutex.synchronize do
+        queued_at = Time.now.utc.iso8601(3)
+        @state_mutex.synchronize { @pending_turns += 1 }
+        @prompt_queue << { prompt: text, queued_at: queued_at }
+      end
       broadcast("queue", queue_payload)
       { ok: true, queued: @prompt_queue.size, active: active? }
     end
@@ -103,6 +106,27 @@ module Kward
 
     private
 
+    def new_conversation
+      Conversation.new(
+        workspace_root: @workspace.root.to_s,
+        provider: (@client.current_provider if @client.respond_to?(:current_provider)),
+        model: (@client.current_model if @client.respond_to?(:current_model)),
+        reasoning_effort: (@client.current_reasoning_effort if @client.respond_to?(:current_reasoning_effort))
+      )
+    end
+
+    def build_agent
+      hook_context = lifecycle_hook_context
+      hook_manager = lifecycle_hook_manager
+      Agent.new(
+        client: @client,
+        tool_registry: ToolRegistry.new(workspace: @workspace, ask_user_question_enabled: false, hook_manager: hook_manager, hook_context: hook_context),
+        conversation: @conversation,
+        hook_manager: hook_manager,
+        hook_context: hook_context
+      )
+    end
+
     def lifecycle_hook_manager
       manager = Hooks::ConfigLoader.new(ConfigFiles.lifecycle_hooks_config(@workspace.root)).manager
       manager.on_result = method(:broadcast_lifecycle_hook_event)
@@ -185,7 +209,10 @@ module Kward
       broadcast("error", { message: e.message })
       broadcast("turn_finished", queue_payload.merge(status: "failed"))
     ensure
-      set_active(false)
+      @state_mutex.synchronize do
+        @active = false
+        @pending_turns -= 1 if @pending_turns.positive?
+      end
       broadcast("queue", queue_payload)
     end
 
@@ -201,12 +228,18 @@ module Kward
       case [request[:method], request[:path]]
       when ["GET", "/"]
         write_response(socket, 200, { "Content-Type" => "text/html; charset=utf-8" }, render_index)
+      when ["GET", "/kward-logo.png"]
+        write_response(socket, 200, { "Content-Type" => "image/png", "Cache-Control" => "public, max-age=86400" }, File.binread(File.join(__dir__, "kward_logo.png")))
       when ["GET", "/transcript"]
-        write_json(socket, 200, transcript: transcript_items, session: { id: @session.id, path: @session.path }, workspace: @workspace.root.to_s)
+        write_json(socket, 200, transcript: transcript_items, session: active_session_payload, workspace: @workspace.root.to_s)
+      when ["GET", "/sessions"]
+        write_json(socket, 200, sessions: session_payloads, activeSessionId: @session.id)
       when ["GET", "/events"]
         stream_events(socket)
       when ["POST", "/turn"]
-        handle_turn(socket, request[:body])
+        handle_turn(socket, request[:body], request[:headers])
+      when ["POST", "/sessions"]
+        handle_session_action(socket, request[:body], request[:headers])
       else
         write_response(socket, 404, { "Content-Type" => "text/plain; charset=utf-8" }, "Not found\n")
       end
@@ -254,7 +287,9 @@ module Kward
       left.bytes.zip(right.bytes).reduce(0) { |memo, pair| memo | (pair[0] ^ pair[1]) }.zero?
     end
 
-    def handle_turn(socket, body)
+    def handle_turn(socket, body, headers)
+      return write_json(socket, 415, ok: false, error: "Content-Type must be application/json") unless json_request?(headers)
+
       params = JSON.parse(body.empty? ? "{}" : body)
       result = enqueue_prompt(params["prompt"])
       status = result[:ok] ? 202 : 422
@@ -263,6 +298,155 @@ module Kward
       write_json(socket, 400, ok: false, error: "Invalid JSON")
     end
 
+    def handle_session_action(socket, body, headers)
+      return write_json(socket, 415, ok: false, error: "Content-Type must be application/json") unless json_request?(headers)
+
+      params = JSON.parse(body.empty? ? "{}" : body)
+      result = update_session(params)
+      write_json(socket, result.delete(:status), result)
+    rescue JSON::ParserError
+      write_json(socket, 400, ok: false, error: "Invalid JSON")
+    end
+
+    def update_session(params)
+      return { status: 409, ok: false, error: "Wait for queued turns to finish before changing sessions" } if turns_pending?
+
+      result = @session_mutex.synchronize do
+        return { status: 409, ok: false, error: "Wait for queued turns to finish before changing sessions" } if turns_pending?
+
+        case params["action"]
+        when "new" then create_session
+        when "resume" then resume_session(params["id"])
+        when "rename" then rename_session(params["id"], params["name"])
+        when "delete" then delete_session(params["id"])
+        else { status: 422, ok: false, error: "Unknown session action" }
+        end
+      end
+      broadcast("session_changed", result[:session]) if result[:ok] && result[:session]
+      result
+    rescue StandardError => e
+      { status: 422, ok: false, error: e.message }
+    end
+
+    def create_session
+      previous = @session
+      session = @session_store.create(
+        provider: (@client.current_provider if @client.respond_to?(:current_provider)),
+        model: (@client.current_model if @client.respond_to?(:current_model)),
+        reasoning_effort: (@client.current_reasoning_effort if @client.respond_to?(:current_reasoning_effort))
+      )
+      conversation = new_conversation
+      session.attach(conversation)
+      activate_session(session, conversation)
+      previous.delete_if_unused
+      { status: 200, ok: true, session: active_session_payload }
+    end
+
+    def resume_session(id)
+      info = find_session(id)
+      return { status: 404, ok: false, error: "Session not found" } unless info
+      return { status: 200, ok: true, session: active_session_payload } if info.id == @session.id
+
+      previous = @session
+      session, conversation = @session_store.load(
+        info.path,
+        workspace: @workspace,
+        provider: (@client.current_provider if @client.respond_to?(:current_provider)),
+        model: (@client.current_model if @client.respond_to?(:current_model)),
+        reasoning_effort: (@client.current_reasoning_effort if @client.respond_to?(:current_reasoning_effort))
+      )
+      activate_session(session, conversation)
+      previous.delete_if_unused
+      { status: 200, ok: true, session: active_session_payload }
+    end
+
+    def rename_session(id, name)
+      clean_name = name.to_s.strip
+      return { status: 422, ok: false, error: "Session name is too long" } if clean_name.length > 120
+
+      target = id.to_s == @session.id ? @session : find_session(id)
+      return { status: 404, ok: false, error: "Session not found" } unless target
+
+      session = target.respond_to?(:rename) ? target : @session_store.load(target.path, workspace: @workspace).first
+      session.rename(clean_name)
+      @session.name = session.name if session.id == @session.id
+      { status: 200, ok: true, session: session_payload(session) }
+    end
+
+    def delete_session(id)
+      if id.to_s == @session.id
+        deleted_id = @session.id
+        deleted_path = @session.path
+        create_session
+        SessionTrash.new.delete(deleted_path)
+        return { status: 200, ok: true, deletedSessionId: deleted_id, session: active_session_payload }
+      end
+
+      info = find_session(id)
+      return { status: 404, ok: false, error: "Session not found" } unless info
+
+      SessionTrash.new.delete(info.path)
+      { status: 200, ok: true, deletedSessionId: info.id }
+    end
+
+    def activate_session(session, conversation)
+      @session = session
+      @conversation = conversation
+      @agent = build_agent
+      @session_store.remember_last_session(session)
+    end
+
+    def find_session(id)
+      session_infos.find { |info| info.id.to_s == id.to_s }
+    end
+
+    def session_infos
+      @session_store.recent(limit: 50, keep_empty_path: @session.path)
+    end
+
+    def session_payloads
+      sessions = session_infos.map { |info| session_payload(info) }
+      sessions.unshift(active_session_payload) unless sessions.any? { |item| item[:id] == @session.id }
+      sessions.sort_by { |item| item[:modifiedAt].to_s }.reverse
+    end
+
+    def active_session_payload
+      info = session_infos.find { |item| item.id == @session.id }
+      return session_payload(info).merge(active: true, path: @session.path) if info
+
+      session_payload(@session).merge(
+        active: true,
+        path: @session.path,
+        modifiedAt: File.mtime(@session.path).utc.iso8601(3),
+        preview: transcript_items.find { |item| item[:role] == "user" }&.fetch(:text, "") || "",
+        messageCount: transcript_items.length
+      )
+    end
+
+    def session_payload(session)
+      name = session.name.to_s.strip
+      preview = session.respond_to?(:first_message) ? session.first_message.to_s : ""
+      {
+        id: session.id,
+        name: name.empty? ? nil : name,
+        title: name.empty? ? (preview.empty? ? "New session" : preview) : name,
+        preview: preview,
+        createdAt: session.created_at&.utc&.iso8601(3),
+        modifiedAt: (session.respond_to?(:modified_at) ? session.modified_at&.utc&.iso8601(3) : nil),
+        messageCount: (session.respond_to?(:message_count) ? session.message_count.to_i : 0),
+        model: (session.respond_to?(:model) ? session.model : @conversation.model),
+        active: session.id == @session.id
+      }
+    end
+
+    def turns_pending?
+      @state_mutex.synchronize { @pending_turns.positive? }
+    end
+
+    def json_request?(headers)
+      headers["content-type"].to_s.downcase.start_with?("application/json")
+    end
+
     def stream_events(socket)
       subscriber = Queue.new
       subscribe(subscriber)
@@ -316,11 +500,38 @@ module Kward
 
     def render_index
       @workspace_root = @workspace.root.to_s
+      @workspace_label = pan_workspace_label
+      @assistant_label = assistant_label
       @session_path = @session.path
+      @version = Kward::VERSION
       template = File.read(File.join(__dir__, "index.html.erb"))
       ERB.new(template).result(binding)
     end
 
+    def assistant_label
+      ConfigFiles.active_persona_label(
+        workspace_root: @conversation.workspace_root,
+        model: @conversation.model,
+        config: @full_config
+      ) || "Assistant"
+    rescue StandardError
+      "Assistant"
+    end
+
+    def pan_workspace_label
+      root = File.expand_path(@workspace.root.to_s)
+      home = Dir.home
+      if root == home || root.start_with?("#{home}/")
+        relative = root.delete_prefix(home).delete_prefix("/")
+        return "~" if relative.empty?
+        return "~/#{relative}" unless relative.include?("/")
+      end
+
+      [File.basename(File.dirname(root)), File.basename(root)].reject(&:empty?).join("/")
+    rescue StandardError
+      @workspace.root.to_s
+    end
+
     def pan_config(config)
       values = config["pan_mode"]
       values.is_a?(Hash) ? values : {}
@@ -332,7 +543,19 @@ module Kward
     end
 
     def display_host
-      @host == "0.0.0.0" ? "<lan-address>" : @host
+      return @host unless @host == "0.0.0.0"
+
+      lan_address || "<lan-address>"
+    end
+
+    def lan_address
+      socket = @udp_socket_class.new
+      socket.connect(ROUTING_PROBE_ADDRESS, ROUTING_PROBE_PORT)
+      socket.addr.last
+    rescue SocketError, SystemCallError
+      nil
+    ensure
+      socket&.close
     end
 
     def set_active(value)
@@ -385,9 +608,9 @@ module Kward
           text.to_s.empty? ? nil : { role: "reasoning", label: "Reasoning", text: text }
         when "text"
           text = part[:text] || part["text"]
-          text.to_s.empty? ? nil : { role: "assistant", label: "Assistant", text: text }
+          text.to_s.empty? ? nil : { role: "assistant", label: assistant_label, text: text }
         when "image"
-          { role: "assistant", label: "Assistant", text: image_part_text(part) }
+          { role: "assistant", label: assistant_label, text: image_part_text(part) }
         when "toolCall"
           { role: "tool", label: "Tool", text: tool_call_part_text(part) }
         end
@@ -442,6 +665,8 @@ module Kward
       when 400 then "Bad Request"
       when 401 then "Unauthorized"
       when 404 then "Not Found"
+      when 409 then "Conflict"
+      when 415 then "Unsupported Media Type"
       when 422 then "Unprocessable Content"
       else "Internal Server Error"
       end

data/lib/kward/plugin_registry.rb

@@ -87,14 +87,17 @@ module Kward
         nil
       end
 
+      # @return [String, nil] active session identifier
       def session_id
         @session&.id
       end
 
+      # @return [String, nil] human-readable active session name
       def session_name
         @session&.name
       end
 
+      # @return [String, nil] saved active session path
       def session_path
         @session&.path
       end
@@ -108,30 +111,45 @@ module Kward
         nil
       end
 
+      # Allows the current lifecycle event to continue.
+      # @return [Hooks::Decision]
       def allow(message = nil, metadata: nil)
         Hooks::Decision.allow(message, metadata: metadata)
       end
 
+      # Denies the current lifecycle event.
+      # @return [Hooks::Decision]
       def deny(message = nil, metadata: nil)
         Hooks::Decision.deny(message, metadata: metadata)
       end
 
+      # Requests frontend approval for the current lifecycle event.
+      # @return [Hooks::Decision]
       def ask(message = nil, metadata: nil)
         Hooks::Decision.ask(message, metadata: metadata)
       end
 
+      # Continues with an event-specific payload replacement.
+      # @param payload [Hash] replacement fields supported by the event
+      # @return [Hooks::Decision]
       def modify(payload, message: nil, metadata: nil)
         Hooks::Decision.modify(payload, message: message, metadata: metadata)
       end
 
+      # Allows the event while recording a warning.
+      # @return [Hooks::Decision]
       def warn(message = nil, metadata: nil)
         Hooks::Decision.warn(message, metadata: metadata)
       end
 
+      # Requests a retry when the current event supports it.
+      # @return [Hooks::Decision]
       def retry(message = nil, payload: nil, metadata: nil)
         Hooks::Decision.retry(message, payload: payload, metadata: metadata)
       end
 
+      # Defers the event when the current workflow supports it.
+      # @return [Hooks::Decision]
       def defer(message = nil, payload: nil, metadata: nil)
         Hooks::Decision.defer(message, payload: payload, metadata: metadata)
       end

data/lib/kward/prompt_interface/editor/auto_indent.rb

@@ -177,7 +177,7 @@ module Kward
       def editor_expected_indent_for_line(line_index)
         line = @editor_state.lines[line_index].to_s
         code = editor_indent_code(line, editor_syntax_language).strip
-        matching_indent = editor_matching_indent_for_line(code)
+        matching_indent = editor_matching_indent_for_line(code, line_index)
         return matching_indent if matching_indent
 
         previous_line = previous_non_blank_editor_line(line_index)
@@ -188,11 +188,11 @@ module Kward
         indent
       end
 
-      def editor_matching_indent_for_line(code)
+      def editor_matching_indent_for_line(code, line_index = nil)
         return nil if code.empty?
-        return editor_matching_punctuation_indent(code[0]) if editor_closing_punctuation?(code[0])
+        return editor_matching_punctuation_indent(code[0], line_index) if editor_closing_punctuation?(code[0])
 
-        editor_matching_word_indent if editor_completed_word_closer?(code, editor_syntax_language)
+        editor_matching_word_indent(line_index) if editor_completed_word_closer?(code, editor_syntax_language)
       end
 
       def previous_non_blank_editor_line(line_index)
@@ -371,7 +371,8 @@ module Kward
       def editor_reindent_for_closing_punctuation(text)
         return unless editor_cursor_in_leading_indent?
 
-        indent = editor_matching_punctuation_indent(text)
+        line_index, = @editor_state.cursor_line_and_column
+        indent = editor_matching_punctuation_indent(text, line_index)
         editor_reindent_current_line(indent) if indent
       end
 
@@ -381,7 +382,7 @@ module Kward
         before_cursor = line[0...column].to_s
         return unless editor_completed_word_closer?(before_cursor, editor_syntax_language)
 
-        indent = editor_matching_word_indent
+        indent = editor_matching_word_indent(line_index)
         editor_reindent_current_line(indent) if indent
       end
 
@@ -394,14 +395,21 @@ module Kward
       def editor_reindent_current_line(indent)
         line_index, column = @editor_state.cursor_line_and_column
         line_start = @editor_state.line_start_offset(line_index)
-        line = @editor_state.lines[line_index].to_s
-        old_indent = line[/\A[ \t]*/].to_s
+        old_indent = @editor_state.lines[line_index].to_s[/\A[ \t]*/].to_s
+        return false unless editor_reindent_line(line_index, indent)
+
+        content_column = [column - old_indent.length, 0].max
+        @editor_state.cursor = line_start + indent.to_s.length + content_column
+        true
+      end
+
+      def editor_reindent_line(line_index, indent)
+        line_start = @editor_state.line_start_offset(line_index)
+        old_indent = @editor_state.lines[line_index].to_s[/\A[ \t]*/].to_s
         new_indent = indent.to_s
         return false if old_indent == new_indent
 
-        content_column = [column - old_indent.length, 0].max
         @editor_state.replace_range(line_start, line_start + old_indent.length, new_indent)
-        @editor_state.cursor = line_start + new_indent.length + content_column
         true
       end
 
@@ -421,23 +429,23 @@ module Kward
         end
       end
 
-      def editor_matching_word_indent
+      def editor_matching_word_indent(line_index = nil)
         case editor_syntax_language
         when :ruby
-          editor_matching_keyword_indent("end", %w[end])
+          editor_matching_keyword_indent("end", %w[end], line_index)
         when :lua
-          editor_matching_keyword_indent("end", %w[end until])
+          editor_matching_keyword_indent("end", %w[end until], line_index)
         when :shell
-          editor_matching_keyword_indent(nil, SHELL_DEDENT_KEYWORDS)
+          editor_matching_keyword_indent(nil, SHELL_DEDENT_KEYWORDS, line_index)
         when :html
-          editor_matching_html_indent
+          editor_matching_html_indent(line_index)
         end
       end
 
-      def editor_matching_punctuation_indent(text)
+      def editor_matching_punctuation_indent(text, line_index = nil)
         opener = PUNCTUATION_PAIRS[text]
         stack = []
-        editor_previous_code_lines.each do |line|
+        editor_previous_code_lines(line_index).each do |line|
           editor_scan_punctuation_tokens(line[:code]).each do |token|
             if token == opener
               stack << line[:indent]
@@ -449,9 +457,9 @@ module Kward
         stack.last || ""
       end
 
-      def editor_matching_keyword_indent(opener = nil, closers = [])
+      def editor_matching_keyword_indent(opener = nil, closers = [], line_index = nil)
         stack = []
-        editor_previous_code_lines.each do |line|
+        editor_previous_code_lines(line_index).each do |line|
           code = line[:code].strip
           next if code.empty?
 
@@ -461,9 +469,9 @@ module Kward
         stack.last || ""
       end
 
-      def editor_matching_html_indent
+      def editor_matching_html_indent(line_index = nil)
         stack = []
-        editor_previous_code_lines.each do |line|
+        editor_previous_code_lines(line_index).each do |line|
           code = line[:code].strip
           next if code.empty?
 
@@ -473,8 +481,8 @@ module Kward
         stack.last || ""
       end
 
-      def editor_previous_code_lines
-        line_index, = @editor_state.cursor_line_and_column
+      def editor_previous_code_lines(line_index = nil)
+        line_index ||= @editor_state.cursor_line_and_column.first
         @editor_state.lines.first(line_index).filter_map do |line|
           code = editor_indent_code(line, editor_syntax_language).rstrip
           next if code.strip.empty?

data/lib/kward/prompt_interface/editor/modes/vibe.rb

@@ -452,9 +452,10 @@ module Kward
         return true if command.match?(/\A\d*g\z/)
         return true if command.match?(/\A\d*g[uU~]\z/)
         return true if command.match?(/\A\d*z\z/)
-        return true if command.match?(/\A\d*[cdy]\d*\z/)
-        return true if command.match?(/\A\d*[cdy]\d*[ai]\z/)
-        return true if command.match?(/\A\d*[cdy]\d*[fFtT]\z/)
+        return true if command.match?(/\A\d*[=cdy](?:[1-9]\d*)?\z/)
+        return true if command.match?(/\A\d*[=cdy]\d*g\z/)
+        return true if command.match?(/\A\d*[=cdy]\d*[ai]\z/)
+        return true if command.match?(/\A\d*[=cdy]\d*[fFtT]\z/)
         return true if command.match?(/\A\d*[fFtT]\z/)
         return true if command.match?(/\A\d*r\z/)
         return true if command.match?(/\Am\z/)
@@ -635,6 +636,10 @@ module Kward
         when "<<"
           vibe_indent_lines(count, :left)
           vibe_remember_change(command)
+        when "=="
+          vibe_reindent_lines(count, command)
+        when /\A=(.+)\z/
+          vibe_reindent_operator(Regexp.last_match(1), count, command)
         when "p"
           vibe_active_register_linewise? ? vibe_paste_line(:below, original_command) : vibe_paste_after(original_command)
         when "P"
@@ -704,6 +709,8 @@ module Kward
           vibe_indent_visual_selection(:right)
         when "<"
           vibe_indent_visual_selection(:left)
+        when "="
+          vibe_reindent_visual_selection
         when "J"
           vibe_join_visual_selection
         when "~"
@@ -1077,6 +1084,18 @@ module Kward
         vibe_cancel_visual_mode
       end
 
+      def vibe_reindent_visual_selection
+        ranges = @editor_state.selection_ranges
+        return false if ranges.empty?
+
+        start_index = ranges.map(&:first).min
+        end_index = ranges.map(&:last).max
+        start_line, = @editor_state.cursor_line_and_column_for(start_index)
+        end_line, = @editor_state.cursor_line_and_column_for([end_index - 1, start_index].max)
+        vibe_reindent_line_range(start_line, end_line)
+        vibe_cancel_visual_mode
+      end
+
       def vibe_count_and_body(command)
         return [0, "0"] if command == "0"
 
@@ -1284,6 +1303,56 @@ module Kward
         true
       end
 
+      def vibe_reindent_lines(count, command = nil)
+        line, = @editor_state.cursor_line_and_column
+        vibe_reindent_line_range(line, line + count - 1, command)
+      end
+
+      def vibe_reindent_operator(motion, count, command = nil)
+        motion_count, motion = vibe_count_and_body(motion)
+        return vibe_reindent_to_line(motion_count, command) if motion == "G"
+        return vibe_reindent_to_line(motion_count.positive? ? motion_count : 1, command) if motion == "gg"
+        return vibe_reindent_lines(count, command) if motion == "=" || motion == "g_"
+
+        count *= motion_count if motion_count.positive?
+        target = vibe_operator_target(motion, count)
+        return false unless target
+
+        vibe_reindent_target(target, motion, command)
+      end
+
+      def vibe_reindent_to_line(line_count, command)
+        line, = @editor_state.cursor_line_and_column
+        target_line = line_count.positive? ? line_count - 1 : @editor_state.lines.length - 1
+        vibe_reindent_line_range(line, target_line, command)
+      end
+
+      def vibe_reindent_target(target, motion, command)
+        start_line, = @editor_state.cursor_line_and_column_for(target.start_index)
+        end_line = if motion.match?(/\A[ai].\z/)
+                     @editor_state.cursor_line_and_column_for([target.end_index - 1, target.start_index].max).first
+                   else
+                     @editor_state.cursor_line_and_column.first
+                   end
+        vibe_reindent_line_range(start_line, end_line, command)
+      end
+
+      def vibe_reindent_line_range(first_line, last_line, command = nil)
+        start_line, end_line = [first_line, last_line].minmax
+        end_line = [end_line, @editor_state.lines.length - 1].min
+        vibe_record_undo do
+          (start_line..end_line).each do |line_index|
+            next if @editor_state.lines[line_index].to_s.strip.empty?
+
+            editor_reindent_line(line_index, editor_expected_indent_for_line(line_index))
+          end
+        end
+        @editor_state.move_to_line_first_non_blank(end_line)
+        @editor_state.status = "Reindented #{end_line - start_line + 1} line#{end_line == start_line ? "" : "s"}"
+        vibe_remember_change(command) if command
+        true
+      end
+
       def vibe_change_lines(count, command = nil)
         start_index, end_index = vibe_linewise_change_range(count)
         @editor_state.copy_range(start_index, end_index)