kward 0.67.1 → 0.69.0

data/lib/kward/cli/slash_commands.rb

@@ -0,0 +1,114 @@
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Command-line frontend that coordinates terminal interaction, sessions, tools, and model turns.
+  class CLI
+    # Interactive slash-command parsing and dispatch helpers.
+    module SlashCommands
+      private
+
+      def handle_local_slash_command(command, agent, session_store)
+        name, argument = parse_slash_command(command)
+        case name
+        when "status"
+          run_busy_local_command_and_requeue { print_status }
+          [true, nil]
+        when "stats"
+          run_busy_local_command_and_requeue { print_stats(argument) }
+          [true, nil]
+        when "memory"
+          activity = memory_summarize_command?(argument) ? "summarizing" : "loading"
+          run_busy_local_command_and_requeue(activity: activity) { handle_memory_command(argument, agent) }
+          [true, nil]
+        when "redraw"
+          run_busy_local_command_and_requeue { @prompt.redraw if @prompt.respond_to?(:redraw) }
+          [true, nil]
+        when "settings"
+          configure_settings(agent.conversation)
+          [true, nil]
+        when "login"
+          login_interactively
+          [true, nil]
+        when "model"
+          models = run_busy_local_command_and_requeue { normalized_available_models }
+          configure_model(agent.conversation, models: models)
+          [true, nil]
+        when "openrouter/catalog"
+          run_busy_local_command_and_requeue { print_openrouter_catalog }
+          [true, nil]
+        when "reasoning"
+          configure_reasoning(agent.conversation)
+          [true, nil]
+        when "reload"
+          run_busy_local_command_and_requeue { reload_plugins(agent.conversation) }
+          [true, nil]
+        when "new"
+          [true, run_busy_local_command_and_requeue { start_new_session(session_store) }]
+        when "resume"
+          [true, run_busy_local_command_and_requeue do
+            path = argument.to_s.strip
+            path = select_session_path(session_store) if session_store && path.empty?
+            resume_session(session_store, path)
+          end]
+        when "name"
+          run_busy_local_command_and_requeue { rename_session(argument) }
+          [true, nil]
+        when "clone"
+          [true, run_busy_local_command_and_requeue { clone_session(session_store, agent) }]
+        when "tree"
+          [true, run_busy_local_command_and_requeue { navigate_session_tree(session_store) }]
+        when "copy"
+          run_busy_local_command_and_requeue { copy_session_text(agent.conversation, argument) }
+          [true, nil]
+        when "export"
+          run_busy_local_command_and_requeue { export_session(agent.conversation, argument) }
+          [true, nil]
+        when "compact"
+          run_busy_local_command_and_requeue(activity: "compacting") { compact_context(agent, argument) }
+          [true, nil]
+        else
+          if plugin_command_for(name)
+            run_busy_local_command_and_requeue(activity: "running") { run_plugin_command(name, argument, agent) }
+          else
+            [false, nil]
+          end
+        end
+      end
+
+      def parse_slash_command(command)
+        PromptCommands.parse(command) || [nil, ""]
+      end
+
+      # Writes the status output for the terminal CLI flow.
+      def print_status
+        lines = [STATUS_MESSAGE]
+        lines << ""
+        lines << auto_compaction_status_line
+        if @active_session
+          lines << "Session: #{@active_session.name || @active_session.id}"
+          lines << "File: #{@active_session.path}"
+        end
+        lines.compact!
+        runtime_output(lines.join("\n"))
+      end
+
+      def auto_compaction_status_line
+        settings = Kward::Compaction::Settings.from_config
+        return "Auto-compaction: disabled" unless settings.enabled
+
+        context_window = composer_context_window
+        return "Auto-compaction: enabled, unknown context window" unless context_window.to_i.positive?
+
+        reserve_tokens = Kward::Compactor.auto_compaction_reserve_tokens(
+          context_window: context_window,
+          configured_reserve_tokens: settings.reserve_tokens
+        )
+        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}"
+        nil
+      end
+
+    end
+  end
+end

data/lib/kward/cli/stats.rb

@@ -0,0 +1,64 @@
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Command-line frontend that coordinates terminal interaction, sessions, tools, and model turns.
+  class CLI
+    # Token statistics command helpers mixed into the CLI frontend.
+    module Stats
+      private
+
+      def export_token_stats(arguments)
+        options = parse_token_stats_options(arguments)
+        csv = TelemetryStats.new.token_usage_csv(options[:range], bucket: options[:bucket])
+        if options[:output]
+          File.write(options[:output], csv)
+        else
+          $stdout.write(csv)
+        end
+      rescue ArgumentError => e
+        warn e.message
+        warn "Usage: kward stats tokens [range] [--bucket second|minute|hour|day|week|month|year] [--output path]"
+        exit 1
+      end
+
+      def parse_token_stats_options(arguments)
+        remaining = []
+        bucket = nil
+        output = nil
+        index = 0
+        while index < arguments.length
+          argument = arguments[index]
+          case argument
+          when "--bucket"
+            index += 1
+            raise ArgumentError, "Missing value for --bucket" if index >= arguments.length
+
+            bucket = arguments[index]
+          when /\A--bucket=(.+)\z/
+            bucket = Regexp.last_match(1)
+          when "--output"
+            index += 1
+            raise ArgumentError, "Missing value for --output" if index >= arguments.length
+
+            output = arguments[index]
+          when /\A--output=(.+)\z/
+            output = Regexp.last_match(1)
+          else
+            remaining << argument
+          end
+          index += 1
+        end
+        { range: remaining.join(" "), bucket: bucket, output: output }
+      end
+
+      # Writes the stats output for the terminal CLI flow.
+      def print_stats(argument)
+        result = TelemetryStats.new.collect(argument)
+        runtime_output(TelemetryStats.format(result))
+      rescue ArgumentError => e
+        message = e.message == TelemetryStats::USAGE ? e.message : "#{e.message}\n#{TelemetryStats::USAGE}"
+        runtime_output(message)
+      end
+
+    end
+  end
+end

data/lib/kward/cli/sysprompt.rb

@@ -0,0 +1,57 @@
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Command-line frontend that coordinates terminal interaction, sessions, tools, and model turns.
+  class CLI
+    # System prompt inspection command helpers.
+    module Sysprompt
+      private
+
+      def print_sysprompt(arguments)
+        raw = parse_sysprompt_arguments(arguments)
+        conversation = new_conversation
+        content = conversation.system_message.fetch(:content)
+        if raw
+          @prompt.say(content)
+        else
+          @prompt.say(render_markdown_transcript(render_sysprompt_sections(conversation)))
+        end
+      end
+
+      def parse_sysprompt_arguments(arguments)
+        raw = false
+        arguments.each do |argument|
+          case argument
+          when "--raw"
+            raw = true
+          else
+            raise ArgumentError, command_usage("sysprompt")
+          end
+        end
+        raw
+      end
+
+      def render_sysprompt_sections(conversation)
+        sections = Prompts.prompt_sections(
+          workspace_root: conversation.workspace_root,
+          model: conversation.model,
+          reasoning_effort: conversation.reasoning_effort,
+          memory_context: conversation.memory_context,
+          plugin_context: conversation.last_plugin_prompt_context
+        )
+        lines = ["# Kward System Prompt", "", "Workspace: #{conversation.workspace_root}"]
+        lines << "Model: #{[conversation.provider, conversation.model].compact.join(" / ")}" unless conversation.model.to_s.empty?
+        lines << "Reasoning effort: #{conversation.reasoning_effort}" unless conversation.reasoning_effort.to_s.empty?
+        lines << "Memory: not included; memory context is retrieved per user turn."
+        sections.each do |section|
+          lines << ""
+          lines << "## #{section.fetch(:label)}"
+          source = section[:source]
+          lines << "Source: #{source}" unless source.to_s.empty?
+          lines << ""
+          lines << section.fetch(:content)
+        end
+        lines.join("\n")
+      end
+    end
+  end
+end

data/lib/kward/cli/tool_summaries.rb

@@ -0,0 +1,157 @@
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Command-line frontend that coordinates terminal interaction, sessions, tools, and model turns.
+  class CLI
+    # Compact tool-output summaries for terminal display and restored transcripts.
+    module ToolSummaries
+      private
+
+      def tool_result_summary(tool_call, content)
+        name = tool_call_name(tool_call)
+        args = tool_call_args(tool_call)
+        text = content.to_s
+        return error_tool_summary(name, args, text) if tool_result_failed?(text)
+
+        case name
+        when "read_file"
+          read_file_summary(args, text)
+        when "write_file", "edit_file"
+          file_change_summary(name, args, text)
+        when "run_shell_command"
+          shell_command_summary(args, text)
+        when "web_search"
+          web_search_summary(args, text)
+        else
+          generic_tool_summary(name, text)
+        end
+      end
+
+      def tool_result_failed?(content)
+        content.to_s.start_with?("Error:", "Declined:", "Cancelled.")
+      end
+
+      def limit_tool_output_lines(content, line_limit)
+        lines = content.to_s.lines
+        return content.to_s if lines.length <= line_limit
+
+        kept_lines = lines.first(line_limit - 1).join
+        omitted_lines = lines.length - (line_limit - 1)
+        suffix = omitted_lines == 1 ? "line" : "lines"
+        notice = "...[truncated #{omitted_lines} #{suffix}]"
+        kept_lines.end_with?("\n") || kept_lines.empty? ? "#{kept_lines}#{notice}" : "#{kept_lines}\n#{notice}"
+      end
+
+      def read_file_summary(args, content)
+        path = args["path"] || args[:path] || "(unknown path)"
+        "read_file: #{path}\n#{content.lines.count} lines, #{content.bytesize} bytes"
+      end
+
+      def file_change_summary(name, args, content)
+        path = args["path"] || args[:path] || path_from_tool_result(content) || "(unknown path)"
+        concise = content.lines.first.to_s.strip
+        concise = "completed" if concise.empty?
+        "#{name}: #{path}\n#{concise}"
+      end
+
+      def shell_command_summary(args, content)
+        command = args["command"] || args[:command] || ""
+        lines = ["run_shell_command: #{command}".strip]
+        lines << "Exit status: #{shell_exit_status(content) || "unknown"}"
+        stdout = shell_section(content, "STDOUT")
+        stderr = shell_section(content, "STDERR")
+        lines << compact_stream_summary("stdout", stdout) unless stdout.empty?
+        lines << compact_stream_summary("stderr", stderr) unless stderr.empty?
+        lines.join("\n")
+      end
+
+      def web_search_summary(args, content)
+        queries = Array(args["queries"] || args[:queries]).map(&:to_s)
+        queries = web_search_queries_from_content(content) if queries.empty?
+        counts = web_search_result_counts(content)
+        lines = ["web_search"]
+        queries.each do |query|
+          lines << "#{query}: #{counts.fetch(query, 0)} result(s)"
+        end
+        lines << "#{web_search_total_count(content)} result(s)" if queries.empty?
+        lines.join("\n")
+      end
+
+      def error_tool_summary(name, args, content)
+        path = args["path"] || args[:path]
+        command = args["command"] || args[:command]
+        context = path || command
+        [name, context, content.lines.first.to_s.strip].compact.reject(&:empty?).join("\n")
+      end
+
+      def generic_tool_summary(name, content)
+        text = content.to_s
+        return "#{name}: #{text}" if text.length <= RESTORED_TOOL_OUTPUT_LIMIT
+
+        "#{name}: #{text[0, RESTORED_TOOL_OUTPUT_LIMIT]}\n...[truncated #{text.length - RESTORED_TOOL_OUTPUT_LIMIT} bytes]"
+      end
+
+      def compact_stream_summary(label, text)
+        summary = text.strip
+        summary = summary[0, 500] + "\n...[truncated #{summary.length - 500} chars]" if summary.length > 500
+        "#{label} (#{text.bytesize} bytes):#{summary.empty? ? "" : "\n#{summary}"}"
+      end
+
+      def shell_exit_status(content)
+        content.match(/^Exit status: ([^\n]+)/)&.[](1)
+      end
+
+      def shell_section(content, name)
+        match = content.match(/^#{Regexp.escape(name)}:\n(.*?)(?=\nSTD(?:OUT|ERR):\n|\z)/m)
+        match ? match[1] : ""
+      end
+
+      def web_search_queries_from_content(content)
+        content.scan(/^## Query: (.+)$/).flatten
+      end
+
+      def web_search_result_counts(content)
+        counts = {}
+        current_query = nil
+        content.each_line do |line|
+          if (match = line.match(/^## Query: (.+)$/))
+            current_query = match[1]
+            counts[current_query] ||= 0
+          elsif current_query && line.match?(/^\d+\. /)
+            counts[current_query] += 1
+          end
+        end
+        counts
+      end
+
+      def web_search_total_count(content)
+        content.each_line.count { |line| line.match?(/^\d+\. /) }
+      end
+
+      def path_from_tool_result(content)
+        content.match(/\b(?:to|file|Edited)\s+([^:\n]+?)(?:\s|:|\z)/)&.[](1)
+      end
+
+      def tool_call_name(tool_call)
+        ToolCall.name(tool_call) || "unknown_tool"
+      end
+
+      def tool_call_args(tool_call)
+        ToolCall.arguments(tool_call)
+      end
+
+      def tool_command(tool_call)
+        name = tool_call_name(tool_call)
+        args = tool_call_args(tool_call)
+
+        if name == "run_shell_command"
+          args["command"] || args[:command] || ""
+        elsif args.empty?
+          name.to_s
+        else
+          "#{name} #{JSON.dump(args)}"
+        end
+      end
+
+    end
+  end
+end