kward 0.66.0

data/lib/kward/ansi.rb

@@ -0,0 +1,276 @@
+module Kward
+  module ANSI
+    ESCAPE_PATTERN = /\e\[[0-9;?]*[ -\/]*[@-~]/.freeze
+    SGR_PATTERN = /\e\[[0-9;:]*m/.freeze
+    OSC_PATTERN = /\e\][^\a]*(?:\a|\e\\)/m.freeze
+    STRING_ESCAPE_PATTERN = /\e[P_X^][\s\S]*?\e\\/m.freeze
+    STYLES = {
+      reset: 0,
+      bold: 1,
+      dim: 2,
+      italic: 3,
+      strikethrough: 9,
+      red: 31,
+      green: 32,
+      yellow: 33,
+      blue: 34,
+      magenta: 35,
+      cyan: 36,
+      gray: 90,
+      grey: 90,
+      primary_green: "38;2;138;160;106",
+      bright_accent_green: "38;2;155;255;0",
+      augen: "38;2;155;255;0",
+      dark_forest_green: "38;2;78;88;53",
+      stone: "38;2;196;192;178",
+      metal_dark: "38;2;42;42;42",
+      background: "38;2;22;24;22"
+    }.freeze
+
+    module_function
+
+    def enabled?(output = $stdout, env: ENV)
+      setting = env["KWARD_COLOR"].to_s.downcase
+      return true if %w[always force forced true yes 1].include?(setting)
+      return false if %w[never false no 0].include?(setting)
+      return true if forced_color?(env)
+      return false if disabled_color?(env)
+
+      output.respond_to?(:tty?) && output.tty?
+    end
+
+    def colorize(text, *styles, enabled: enabled?)
+      string = text.to_s
+      return string unless enabled
+
+      codes = styles.flatten.map { |style| STYLES.fetch(style, style) }.compact
+      return string if codes.empty?
+
+      "\e[#{codes.join(";")}m#{string}\e[0m"
+    end
+
+    def strip(text)
+      text.to_s.gsub(ESCAPE_PATTERN, "")
+    end
+
+    def sanitize_transcript(text)
+      string = text.to_s.gsub(OSC_PATTERN, "").gsub(STRING_ESCAPE_PATTERN, "")
+      string.gsub(/\e(?:\[[0-9;:?]*[ -\/]*[@-~]|.)/m) do |sequence|
+        sequence.match?(SGR_PATTERN) ? sequence : ""
+      end
+    end
+
+    def wrap_visible(text, width)
+      line_width = [width.to_i, 1].max
+      rows = []
+      current = +""
+      visible_width = 0
+      string = text.to_s
+      index = 0
+
+      while index < string.length
+        if string[index] == "\e" && (match = string[index..].match(/\A\e\[[0-9;:]*m/))
+          if current.empty? && rows.any?
+            rows[-1] << match[0]
+          else
+            current << match[0]
+          end
+          index += match[0].length
+          next
+        end
+
+        char = string[index]
+        current << char
+        visible_width += 1
+        index += 1
+        if visible_width >= line_width
+          rows << current
+          current = +""
+          visible_width = 0
+        end
+      end
+
+      rows << current unless current.empty?
+      rows
+    end
+
+    def markdown(text, enabled: enabled?)
+      string = text.to_s
+      lines = string.lines(chomp: true)
+      rendered = []
+      in_fence = false
+
+      lines.each do |line|
+        if (match = line.match(/\A\s*```([^`]*)\s*\z/))
+          if in_fence
+            rendered << colorize("└" + "─" * 39, :gray, enabled: enabled)
+            in_fence = false
+          else
+            language = match[1].to_s.strip
+            label = language.empty? ? "code" : "code #{language}"
+            rendered << colorize("┌─ #{label}", :gray, enabled: enabled)
+            in_fence = true
+          end
+          next
+        end
+
+        if in_fence
+          rendered << colorize("│ #{line}", :dim, enabled: enabled)
+        else
+          rendered << markdown_line(line, enabled: enabled)
+        end
+      end
+
+      rendered << colorize("└" + "─" * 39, :gray, enabled: enabled) if in_fence
+      rendered.join("\n") + (string.end_with?("\n") ? "\n" : "")
+    end
+
+    class MarkdownStream
+      def initialize(enabled: ANSI.enabled?)
+        @enabled = enabled
+        @pending = +""
+        @in_fence = false
+      end
+
+      def render(delta, final: false)
+        text = delta.to_s
+        return ANSI.markdown(text, enabled: @enabled) if fast_markdown?(text, final)
+
+        @pending << text
+        rendered = +""
+        while (match = @pending.match(/\r\n|\r|\n/))
+          line = @pending[0...match.begin(0)]
+          @pending = @pending[(match.end(0))..] || +""
+          rendered << render_line(line) << "\n"
+        end
+
+        if final && !@pending.empty?
+          rendered << render_line(@pending)
+          @pending.clear
+        end
+
+        if final && @in_fence
+          rendered << "\n" unless rendered.empty? || rendered.end_with?("\n")
+          rendered << ANSI.colorize("└" + "─" * 39, :gray, enabled: @enabled)
+          @in_fence = false
+        end
+
+        rendered
+      end
+
+      private
+
+      def fast_markdown?(text, final)
+        !final && !@in_fence && @pending.empty? && !text.match?(/[`*~_\[\]>]/)
+      end
+
+      def render_line(line)
+        if (match = line.match(/\A\s*```([^`]*)\s*\z/))
+          if @in_fence
+            @in_fence = false
+            ANSI.colorize("└" + "─" * 39, :gray, enabled: @enabled)
+          else
+            language = match[1].to_s.strip
+            label = language.empty? ? "code" : "code #{language}"
+            @in_fence = true
+            ANSI.colorize("┌─ #{label}", :gray, enabled: @enabled)
+          end
+        elsif @in_fence
+          ANSI.colorize("│ #{line}", :dim, enabled: @enabled)
+        else
+          ANSI.markdown_line(line, enabled: @enabled)
+        end
+      end
+    end
+
+    def markdown_line(line, enabled: enabled?)
+      if (match = line.match(/\A(\#{1,6}\s+)(.+)\z/))
+        markdown_heading(match[1], match[2], enabled: enabled)
+      elsif (match = line.match(/\A(\s*)[-*]\s+\[([ xX])\]\s+(.+)\z/))
+        task_list_item(match[1], match[2], match[3], enabled: enabled)
+      elsif (match = line.match(/\A>\s?(.*)\z/))
+        blockquote(match[1], enabled: enabled)
+      else
+        inline_markdown(line, enabled: enabled)
+      end
+    end
+
+    def markdown_heading(marker, text, enabled: enabled?)
+      "#{marker}#{colorize(text, :bold, enabled: enabled)}"
+    end
+
+    def task_list_item(indent, marker, text, enabled: enabled?)
+      checked = marker.downcase == "x"
+      box = checked ? colorize("☑", :green, enabled: enabled) : colorize("☐", :gray, enabled: enabled)
+      "#{indent}#{box} #{inline_markdown(text, enabled: enabled)}"
+    end
+
+    def blockquote(text, enabled: enabled?)
+      "#{colorize("│", :gray, enabled: enabled)} #{inline_markdown(text, enabled: enabled)}"
+    end
+
+    def inline_markdown(line, enabled: enabled?)
+      line.to_s.split(/(`[^`\n]+`)/).map do |part|
+        if part.start_with?("`") && part.end_with?("`") && part.length > 1
+          "`#{colorize(part[1...-1], :dim, enabled: enabled)}`"
+        else
+          inline_links(part, enabled: enabled)
+        end
+      end.join
+    end
+
+    def inline_links(text, enabled: enabled?)
+      text.split(/(\[[^\]\n]+\]\([^)\s\n]+\))/).map do |part|
+        if (match = part.match(/\A\[([^\]\n]+)\]\(([^)\s\n]+)\)\z/))
+          "#{colorize(match[1], :cyan, enabled: enabled)} (#{colorize(match[2], :dim, enabled: enabled)})"
+        else
+          inline_emphasis(part, enabled: enabled)
+        end
+      end.join
+    end
+
+    def inline_emphasis(text, enabled: enabled?)
+      rendered = inline_bold(text, enabled: enabled)
+      rendered = inline_strikethrough(rendered, enabled: enabled)
+      inline_italic(rendered, enabled: enabled)
+    end
+
+    def inline_bold(text, enabled: enabled?)
+      text.gsub(/\*\*([^\n]+?)\*\*/) do
+        colorize(Regexp.last_match(1), :bold, enabled: enabled)
+      end
+    end
+
+    def inline_strikethrough(text, enabled: enabled?)
+      text.gsub(/~~([^\n]+?)~~/) do
+        colorize(Regexp.last_match(1), :strikethrough, enabled: enabled)
+      end
+    end
+
+    def inline_italic(text, enabled: enabled?)
+      rendered = text.gsub(/(^|[\s\(\[{])\*([^*\n]+?)\*(?=$|[\s\)\]},.!?:;])/) do
+        "#{Regexp.last_match(1)}#{colorize(Regexp.last_match(2), :italic, enabled: enabled)}"
+      end
+      rendered.gsub(/(^|[\s\(\[{])_([^_\n]+?)_(?=$|[\s\)\]},.!?:;])/) do
+        "#{Regexp.last_match(1)}#{colorize(Regexp.last_match(2), :italic, enabled: enabled)}"
+      end
+    end
+
+    def inline_code(line, enabled: enabled?)
+      inline_markdown(line, enabled: enabled)
+    end
+
+    def forced_color?(env)
+      force_color = env["FORCE_COLOR"]
+      clicolor_force = env["CLICOLOR_FORCE"]
+      (force_color && force_color != "0") || (clicolor_force && clicolor_force != "0")
+    end
+
+    def disabled_color?(env)
+      return true if env.key?("NO_COLOR") && !env["NO_COLOR"].to_s.empty?
+      return true if env["CLICOLOR"] == "0"
+
+      env["TERM"] == "dumb"
+    end
+  end
+end

data/lib/kward/auth/file.rb

@@ -0,0 +1,11 @@
+require_relative "../private_file"
+
+module Kward
+  module AuthFile
+    module_function
+
+    def write_json(path, data)
+      PrivateFile.write_json(path, data)
+    end
+  end
+end

data/lib/kward/auth/github_oauth.rb

@@ -0,0 +1,222 @@
+require "json"
+require "net/http"
+require "time"
+require "uri"
+require_relative "file"
+require_relative "../config_files"
+
+module Kward
+  class GithubOAuth
+    DEVICE_CODE_URL = URI("https://github.com/login/device/code")
+    TOKEN_URL = URI("https://github.com/login/oauth/access_token")
+    COPILOT_TOKEN_URL = URI("https://api.github.com/copilot_internal/v2/token")
+    DEFAULT_SCOPE = "read:user"
+    DEFAULT_CLIENT_ID = "Iv1.b507a08c87ecfe98"
+    COPILOT_HEADERS = {
+      "User-Agent" => "GitHubCopilotChat/0.35.0",
+      "Editor-Version" => "vscode/1.107.0",
+      "Editor-Plugin-Version" => "copilot-chat/0.35.0",
+      "Copilot-Integration-Id" => "vscode-chat"
+    }.freeze
+
+    attr_reader :auth_path
+
+    def initialize(auth_path: GithubOAuth.default_auth_path, config_path: ConfigFiles.config_path)
+      @auth_path = File.expand_path(auth_path)
+      @config_path = File.expand_path(config_path)
+    end
+
+    def self.default_auth_path
+      File.expand_path(ENV["KWARD_GITHUB_AUTH_PATH"] || "~/.kward/github_auth.json")
+    end
+
+    def access_token
+      env_token = ENV["COPILOT_GITHUB_TOKEN"].to_s
+      return env_token unless env_token.empty?
+
+      auth = load_auth
+      return nil unless auth
+
+      token = auth.dig("tokens", "copilot_access_token") || auth.dig("tokens", "access")
+      return token if token && !token_expired?(auth)
+
+      github_token = auth.dig("tokens", "github_access_token") || auth.dig("tokens", "refresh") || auth.dig("tokens", "access_token")
+      return token unless github_token
+
+      refreshed = refresh_copilot_token(github_token)
+      save_auth(tokens: auth.fetch("tokens", {}).merge(refreshed))
+      refreshed["copilot_access_token"]
+    end
+
+    def base_url
+      token = access_token.to_s
+      match = token.match(/proxy-ep=([^;]+)/)
+      return "https://#{match[1].sub(/\Aproxy\./, "api.")}" if match
+
+      "https://api.individual.githubcopilot.com"
+    end
+
+    def logged_in?
+      !access_token.to_s.empty?
+    end
+
+    def login(prompt:, timeout_seconds: 900)
+      device = request_device_code
+      prompt.say("GitHub login URL: #{device.fetch("verification_uri")}")
+      prompt.say("GitHub device code: #{device.fetch("user_code")}")
+      prompt.say("Authorize Kward in your browser, then wait for login to complete.")
+
+      github_tokens = poll_for_token(
+        device_code: device.fetch("device_code"),
+        interval: positive_integer(device["interval"]) || 5,
+        timeout_seconds: timeout_seconds
+      )
+      copilot_tokens = refresh_copilot_token(github_tokens.fetch("access_token"))
+      tokens = github_tokens.merge("github_access_token" => github_tokens.fetch("access_token")).merge(copilot_tokens)
+      save_auth(tokens: tokens)
+      auth_path
+    end
+
+    def save_auth(tokens: {})
+      data = {
+        "auth_mode" => "github_oauth",
+        "tokens" => tokens,
+        "saved_at" => Time.now.utc.iso8601,
+        "expires_at" => expires_at_for(tokens)
+      }.compact
+
+      AuthFile.write_json(@auth_path, data)
+    end
+
+    private
+
+    def refresh_copilot_token(github_token)
+      response = get_json(COPILOT_TOKEN_URL, "Authorization" => "Bearer #{github_token}")
+      data = parse_successful_json(response, "GitHub Copilot token")
+      token = data["token"].to_s
+      expires_at = data["expires_at"].to_i
+      raise "GitHub Copilot token response missing token" if token.empty?
+
+      {
+        "copilot_access_token" => token,
+        "access" => token,
+        "copilot_expires_at" => expires_at.positive? ? Time.at(expires_at).utc.iso8601 : nil
+      }.compact
+    end
+
+    def load_auth
+      return nil unless File.exist?(@auth_path)
+
+      JSON.parse(File.read(@auth_path))
+    rescue JSON::ParserError
+      nil
+    end
+
+    def request_device_code
+      response = post_form(DEVICE_CODE_URL,
+        client_id: client_id,
+        scope: scope)
+      parse_successful_json(response, "GitHub OAuth device code")
+    end
+
+    def poll_for_token(device_code:, interval:, timeout_seconds:)
+      deadline = Time.now + timeout_seconds.to_i
+      loop do
+        response = post_form(TOKEN_URL,
+          client_id: client_id,
+          device_code: device_code,
+          grant_type: "urn:ietf:params:oauth:grant-type:device_code")
+        data = parse_json(response, "GitHub OAuth token poll")
+        return data if response.is_a?(Net::HTTPSuccess) && data["access_token"].to_s != ""
+
+        case data["error"].to_s
+        when "authorization_pending"
+          # keep polling
+        when "slow_down"
+          interval += 5
+        when "expired_token"
+          raise "GitHub OAuth device code expired"
+        else
+          raise "GitHub OAuth token poll failed: #{data["error_description"] || data["error"] || response.body}"
+        end
+
+        raise "GitHub OAuth login timed out" if Time.now >= deadline
+
+        sleep interval
+      end
+    end
+
+    def post_form(uri, params)
+      request = Net::HTTP::Post.new(uri)
+      request["Content-Type"] = "application/x-www-form-urlencoded"
+      request["Accept"] = "application/json"
+      request.body = URI.encode_www_form(params)
+
+      COPILOT_HEADERS.each { |key, value| request[key] ||= value }
+      Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
+    end
+
+    def get_json(uri, headers = {})
+      request = Net::HTTP::Get.new(uri)
+      request["Accept"] = "application/json"
+      COPILOT_HEADERS.merge(headers).each { |key, value| request[key] = value }
+
+      Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
+    end
+
+    def parse_successful_json(response, label)
+      data = parse_json(response, label)
+      return data if response.is_a?(Net::HTTPSuccess) && data["error"].to_s.empty?
+
+      raise "#{label} failed: #{data["error_description"] || data["error"] || response.body}"
+    end
+
+    def parse_json(response, label)
+      JSON.parse(response.body.to_s)
+    rescue JSON::ParserError => e
+      raise "#{label} returned invalid JSON: #{e.message}"
+    end
+
+    def client_id
+      value = ENV["GITHUB_OAUTH_CLIENT_ID"].to_s.strip
+      return value unless value.empty?
+
+      value = ConfigFiles.config_value(load_config, "github_oauth_client_id")
+      return value unless value.to_s.empty?
+
+      DEFAULT_CLIENT_ID
+    end
+
+    def scope
+      ENV["GITHUB_OAUTH_SCOPE"].to_s.strip.empty? ? ConfigFiles.config_value(load_config, "github_oauth_scope") || DEFAULT_SCOPE : ENV["GITHUB_OAUTH_SCOPE"].to_s.strip
+    end
+
+    def load_config
+      ConfigFiles.read_config(@config_path)
+    end
+
+    def expires_at_for(tokens)
+      copilot_expires_at = tokens["copilot_expires_at"] || tokens[:copilot_expires_at]
+      return copilot_expires_at if copilot_expires_at
+
+      expires_in = tokens["expires_in"] || tokens[:expires_in]
+      return nil unless expires_in.to_i.positive?
+
+      (Time.now.utc + expires_in.to_i).iso8601
+    end
+
+    def token_expired?(auth)
+      expires_at = auth&.fetch("expires_at", nil)
+      return false unless expires_at
+
+      Time.parse(expires_at) <= Time.now.utc + 60
+    rescue ArgumentError
+      false
+    end
+
+    def positive_integer(value)
+      integer = value.to_i
+      integer.positive? ? integer : nil
+    end
+  end
+end