canopus 0.4.0 → 0.5.0

data/lib/canopus/buffer.rb

@@ -2,55 +2,110 @@
 
 require "digest"
 require "tempfile"
+require "denebola"
+require_relative "denebola_compat"
+menkar_path = ENV["MENKAR_PATH"]
+menkar_root = File.expand_path("../..", __dir__)
+menkar_path ? require(File.expand_path("lib/menkar", File.expand_path(menkar_path, menkar_root))) : require("menkar")
 
 module Canopus
   class Buffer
     Transaction = Struct.new(:before, :after, :before_selections, :after_selections, :patch, :kind, :time)
     Anchor = Data.define(:id, :bias)
-    attr_reader :rope, :path, :encoding, :line_ending, :version, :history, :read_only, :disk_digest, :bom, :notification_errors
+    attr_reader :rope, :path, :encoding, :line_ending, :newline, :version, :history, :read_only, :disk_digest,
+      :bom, :detection, :notification_errors
     attr_accessor :selections
 
-    def self.open(path, large_file_threshold: 100 << 20)
+    def self.open(path, large_file_threshold: 100 << 20, encoding: nil)
       if File.size(path) >= large_file_threshold
+        detection = detect_file(path, encoding: encoding)
+        raise Error, "large-file mode requires UTF-8 text" unless detection.encoding == Encoding::UTF_8
         require_relative "lazy_rope"
-        rope = LazyRope.new(path)
-        return new("", path: path, read_only: true, rope: rope)
+        rope = Denebola::LazyRope.open(path, chunk_size: 65_536, cache_chunks: 32)
+        rope.line_count(exact: true)
+        return new("", path: path, read_only: true, rope: rope, encoding: detection.encoding,
+          bom: detection.bom, detection: detection)
       end
       raw = File.binread(path)
-      text, encoding, bom = decode_bytes(raw)
-      new(text, path: path, encoding: encoding, bom: bom, disk_digest: Digest::SHA256.hexdigest(raw))
+      detection = detect_bytes(raw, encoding: encoding)
+      raise Error, "cannot edit binary file" if detection.binary
+      text = Menkar.decode(raw, detection)
+      new(text, path: path, encoding: detection.encoding, bom: detection.bom, detection: detection,
+        disk_digest: Digest::SHA256.hexdigest(raw))
+    rescue Menkar::Error => error
+      raise Error, error.message
     rescue EncodingError => error
       raise Error, "cannot decode #{path}: #{error.message}"
     end
 
+    def self.detect_file(path, encoding: nil)
+      return Menkar.detect_file(path) unless encoding
+
+      sample = File.open(path, "rb") { |file| file.read(Menkar::DEFAULT_SAMPLE + 1) || "".b }
+      detect_bytes(sample, encoding: encoding)
+    rescue Menkar::Error => error
+      raise Error, error.message
+    end
+    private_class_method :detect_file
+
+    def self.detect_bytes(raw, encoding: nil)
+      requested = encoding && Menkar.detect("".b, hint: encoding).encoding
+      detected = Menkar.detect(raw, hint: requested || bom_encoding(raw))
+      detected = legacy_japanese_detection(raw, detected) unless requested || !detected.bom.empty?
+      return detected unless requested
+      return detected unless detected.bom.empty?
+
+      Menkar.detect(raw, hint: requested).with(encoding: requested, confidence: 1.0, bom: "".b, binary: false)
+    end
+    private_class_method :detect_bytes
+
     # Decode worktree files and historical Git blobs by the same rules.
     # @return [Array(String, Encoding, String)] UTF-8 text, source encoding, BOM
     def self.decode_bytes(raw)
       raw = raw.b unless raw.encoding == Encoding::BINARY
-      bom, encoding = if raw.start_with?("\xEF\xBB\xBF".b)
-        ["\xEF\xBB\xBF".b, Encoding::UTF_8]
-      elsif raw.start_with?("\xFF\xFE".b)
-        ["\xFF\xFE".b, Encoding::UTF_16LE]
-      elsif raw.start_with?("\xFE\xFF".b)
-        ["\xFE\xFF".b, Encoding::UTF_16BE]
-      elsif raw.dup.force_encoding(Encoding::UTF_8).valid_encoding?
-        ["".b, Encoding::UTF_8]
-      else
-        ["".b, Encoding::Windows_31J]
-      end
-      text = raw.byteslice(bom.bytesize..).force_encoding(encoding).encode(Encoding::UTF_8)
-      raise Error, "binary file contains NUL bytes" if text.include?("\0")
-      [text, encoding, bom]
+      detection = detect_bytes(raw)
+      nul_binary = raw.include?("\0") && detection.bom.empty? && raw.bytesize < 8
+      raise Error, "binary file contains NUL bytes" if detection.binary || (detection.encoding.nil? && raw.include?("\0")) || nul_binary
+      [Menkar.decode(raw, detection), detection.encoding, detection.bom]
+    rescue Menkar::Error => error
+      raise Error, error.message
     end
 
-    def initialize(text = "", path: nil, encoding: Encoding::UTF_8, bom: "".b, disk_digest: nil, read_only: false, draft: false, rope: nil)
+    def self.bom_encoding(raw)
+      return Encoding::UTF_32LE if raw.start_with?("\xFF\xFE\x00\x00".b)
+      return Encoding::UTF_32BE if raw.start_with?("\x00\x00\xFE\xFF".b)
+      return Encoding::UTF_16LE if raw.start_with?("\xFF\xFE".b)
+      return Encoding::UTF_16BE if raw.start_with?("\xFE\xFF".b)
+      nil
+    end
+    private_class_method :bom_encoding
+
+    def self.legacy_japanese_detection(raw, detected)
+      return detected unless detected.encoding == Encoding::Windows_1252 && raw.match?(/[^\x00-\x7F]/n)
+
+      candidate = Menkar.detect(raw, hint: Encoding::Windows_31J)
+      return detected unless candidate.encoding == Encoding::Windows_31J
+      text = Menkar.decode(raw, candidate)
+      text.match?(/[\p{Han}\p{Hiragana}\p{Katakana}]/) ? candidate : detected
+    rescue Menkar::Error, EncodingError
+      detected
+    end
+    private_class_method :legacy_japanese_detection
+
+    def initialize(text = "", path: nil, encoding: nil, bom: "".b, disk_digest: nil, read_only: false,
+      draft: false, rope: nil, detection: nil)
       @rope = rope || Denebola::Rope.new(text)
+      @save_mutex = Mutex.new
       @path = path && File.expand_path(path)
-      @encoding, @bom, @disk_digest = encoding, bom, disk_digest
+      requested = encoding && Menkar.detect("".b, hint: encoding).encoding
+      @detection = detection || self.class.send(:detection_for_text, text, encoding: requested, bom: bom)
+      @encoding, @bom, @disk_digest = @detection.encoding || requested || Encoding::UTF_8,
+        @detection.bom.empty? ? bom : @detection.bom, disk_digest
       @saved_rope, @version, @history, @redo = @rope, 0, [], []
       @saved_rope = nil if draft
       @listeners, @anchors, @next_anchor, @selections = [], {}, 0, []
       @notification_errors = [].freeze
+      @newline = @detection.newline
       @line_ending = text[/\r\n|\n|\r|\u2028|\u2029/] || "\n"
       @line_ending = if rope.respond_to?(:line_ending)
         rope.line_ending
@@ -60,6 +115,8 @@ module Canopus
         @line_ending
       end
       @read_only = read_only
+    rescue Menkar::Error => error
+      raise Error, error.message
     end
     def text = rope.to_s
     def relocate(path) = @path = File.expand_path(path)
@@ -67,16 +124,16 @@ module Canopus
     def line(row) = rope.line(row)
     def line_count = rope.line_count
     def dirty? = !@rope.equal?(@saved_rope)
-    def reload(force: false)
+    def reload(force: false, encoding: nil)
       raise SaveConflict, "buffer has unsaved changes" if dirty? && !force
       raise Error, "buffer has no file path" unless @path
       if @rope.respond_to?(:lazy?) && @rope.lazy?
-        fresh = Buffer.open(@path, large_file_threshold: 0)
+        fresh = Buffer.open(@path, large_file_threshold: 0, encoding: encoding)
         old = @rope
         apply_snapshot(fresh.rope, Patch::Reload.new(old, fresh.rope))
         old.close
       else
-        fresh = Buffer.open(@path)
+        fresh = Buffer.open(@path, encoding: encoding)
         raise Error, "file grew beyond the editable limit; reopen it read-only" if fresh.read_only
         before, after = text, fresh.text
         if before != after
@@ -92,7 +149,8 @@ module Canopus
         end
       end
       @saved_rope = @rope
-      @disk_digest, @encoding, @bom, @line_ending = fresh.disk_digest, fresh.encoding, fresh.bom, fresh.line_ending
+      @disk_digest, @encoding, @bom, @line_ending, @newline, @detection = fresh.disk_digest, fresh.encoding, fresh.bom,
+        fresh.line_ending, fresh.newline, fresh.detection
       self
     ensure
       fresh&.close unless fresh&.rope.equal?(@rope)
@@ -184,36 +242,98 @@ module Canopus
       true
     end
 
+    # Persistent undo stores edits, not rope snapshots. Rebuilding from the
+    # current file backwards keeps records bounded while retaining Composite's
+    # intermediate coordinate spaces.
+    def persistent_undo_record(max_entries:)
+      entries = @history.last(max_entries)
+      return if entries.empty?
+      {"history" => entries.map { |transaction| persistent_undo_transaction(transaction) }}
+    end
+
+    def restore_persistent_undo!(record)
+      entries = record.fetch("history")
+      raise Error, "invalid persistent undo history" unless entries.is_a?(Array) && !entries.empty?
+      current = @rope
+      restored = entries.reverse_each.map do |entry|
+        raise Error, "invalid persistent undo transaction" unless entry.is_a?(Hash)
+        patch, before = persistent_undo_patch_before(entry.fetch("patch"), current)
+        before_selections = persistent_undo_selections(entry.fetch("before_selections"), before.bytesize)
+        after_selections = persistent_undo_selections(entry.fetch("after_selections"), current.bytesize)
+        kind = entry.fetch("kind")
+        raise Error, "invalid persistent undo kind" unless kind.is_a?(String) && kind.bytesize.between?(1, 128) && kind.match?(/\A[a-zA-Z0-9_:-]+\z/)
+        current = before
+        Transaction.new(before, patch.after, before_selections, after_selections, patch, kind.to_sym, 0.0)
+      end.reverse
+      @history.replace(restored)
+      @redo.clear
+      true
+    end
+
     # Encode first, write and fsync a sibling temporary file, atomically rename.
-    def save(path = @path, force: false)
-      raise Error, "no file path" unless path
-      raise Error, "buffer is read-only" if @read_only
-      destination = File.expand_path(path)
-      destination = File.realpath(destination) if File.symlink?(destination)
-      original = File.file?(destination) ? File.binread(destination) : nil
-      same_file = @path && (File.expand_path(path) == @path || (File.exist?(@path) && File.exist?(destination) && File.identical?(@path, destination)))
-      if !force && same_file && @disk_digest && (!original || Digest::SHA256.hexdigest(original) != @disk_digest)
-        raise SaveConflict, "file changed on disk: #{path}"
-      end
-      raise SaveConflict, "destination exists: #{path}" if !force && original && (!same_file || !@disk_digest)
-      encoded = @bom + text.encode(@encoding).b
-      Tempfile.create([".canopus-", ".tmp"], File.dirname(destination), binmode: true) do |file|
-        file.chmod(File.stat(destination).mode & 0o777) if original
-        file.write(encoded)
-        file.flush
-        file.fsync
-        file.close
-        current = File.file?(destination) ? File.binread(destination) : nil
-        raise SaveConflict, "file changed during save: #{path}" if !force && current != original
-        File.rename(file.path, destination)
+    def save(path = @path, force: false, encoding: nil)
+      @save_mutex.synchronize do
+        raise Error, "no file path" unless path
+        raise Error, "buffer is read-only" if @read_only
+        destination = File.expand_path(path)
+        destination = File.realpath(destination) if File.symlink?(destination)
+        original = File.file?(destination) ? File.binread(destination) : nil
+        same_file = @path && (File.expand_path(path) == @path || (File.exist?(@path) && File.exist?(destination) && File.identical?(@path, destination)))
+        if !force && same_file && @disk_digest && (!original || Digest::SHA256.hexdigest(original) != @disk_digest)
+          raise SaveConflict, "file changed on disk: #{path}"
+        end
+        raise SaveConflict, "destination exists: #{path}" if !force && original && (!same_file || !@disk_digest)
+        snapshot = @rope
+        detection = encoding ? detection_for_encoding(encoding) : @detection
+        encoded = Menkar.encode(snapshot.to_s, detection)
+        Tempfile.create([".canopus-", ".tmp"], File.dirname(destination), binmode: true) do |file|
+          file.chmod(File.stat(destination).mode & 0o777) if original
+          file.write(encoded)
+          file.flush
+          file.fsync
+          file.close
+          current = File.file?(destination) ? File.binread(destination) : nil
+          raise SaveConflict, "file changed during save: #{path}" if !force && current != original
+          File.rename(file.path, destination)
+        end
+        @path = File.expand_path(path)
+        if encoding
+          @detection = detection
+          @encoding, @bom = detection.encoding, detection.bom
+        end
+        @saved_rope, @disk_digest = snapshot, Digest::SHA256.hexdigest(encoded)
+        self
       end
-      @path = File.expand_path(path)
-      @saved_rope, @disk_digest = @rope, Digest::SHA256.hexdigest(encoded)
-      self
     rescue EncodingError => error
       raise Error, "cannot save using #{@encoding}: #{error.message}"
+    rescue Menkar::Error => error
+      raise Error, error.message
+    end
+
+    def roundtrip?(encoding: nil)
+      return true unless @detection && !@detection.binary
+
+      detection = encoding ? detection_for_encoding(encoding) : @detection
+      Menkar.roundtrip?(text, detection)
+    rescue Menkar::Error => error
+      raise Error, error.message
     end
 
+    def mixed_line_endings? = @newline == :mixed
+
+    def convert_line_endings(to: :lf)
+      normalized, = Menkar.normalize_newlines(text, to: to)
+      return false if normalized == text
+
+      edit([[0...rope.bytesize, normalized]], kind: :format)
+      @line_ending, @newline = {lf: "\n", crlf: "\r\n", cr: "\r"}.fetch(to), to
+      @detection = @detection.with(newline: to) if @detection.respond_to?(:with)
+      true
+    rescue Menkar::Error => error
+      raise Error, error.message
+    end
+    alias convert_newlines convert_line_endings
+
     def trim_trailing_whitespace
       changes = []
       rope.line_count.times do |row|
@@ -226,7 +346,128 @@ module Canopus
       edit(changes, kind: :format)
     end
 
+    def ensure_final_newline
+      return false if rope.empty? || text.end_with?("\n", "\r", "\u2028", "\u2029")
+      edit([[rope.bytesize...rope.bytesize, @line_ending]], kind: :format)
+      true
+    end
+
     private
+    def self.detection_for_text(text, encoding:, bom:)
+      detection = Menkar.detect(text.b, hint: encoding)
+      return detection if encoding.nil? && bom.empty?
+
+      detection.with(encoding: encoding || detection.encoding, bom: bom, binary: false)
+    end
+    private_class_method :detection_for_text
+
+    def detection_for_encoding(encoding)
+      encoding = Menkar.detect("".b, hint: encoding).encoding
+      bom = case encoding
+      when Encoding::UTF_16LE then "\xFF\xFE".b
+      when Encoding::UTF_16BE then "\xFE\xFF".b
+      when Encoding::UTF_32LE then "\xFF\xFE\x00\x00".b
+      when Encoding::UTF_32BE then "\x00\x00\xFE\xFF".b
+      else "".b
+      end
+      Menkar::Detection.new(encoding, 1.0, bom, @newline, @detection.indent, false)
+    rescue ArgumentError
+      raise Error, "unknown encoding: #{encoding}"
+    rescue Menkar::Error => error
+      raise Error, error.message
+    end
+    def persistent_undo_transaction(transaction)
+      {"kind" => transaction.kind.to_s,
+        "before_selections" => persistent_undo_selection_list(transaction.before_selections),
+        "after_selections" => persistent_undo_selection_list(transaction.after_selections),
+        "patch" => persistent_undo_patch(transaction.patch)}
+    end
+
+    def persistent_undo_selection_list(selections)
+      raise Error, "unsupported persistent undo selection" unless selections.is_a?(Array) && selections.length <= 10_000
+      selections.map do |selection|
+        values = [selection.id, selection.anchor, selection.head, selection.goal]
+        raise Error, "unsupported persistent undo selection" unless values[0].is_a?(Integer) && values[1].is_a?(Integer) && values[2].is_a?(Integer) && (values[3].nil? || values[3].is_a?(Integer))
+        {"id" => values[0], "anchor" => values[1], "head" => values[2], "goal" => values[3]}
+      end
+    end
+
+    def persistent_undo_patch(patch)
+      case patch
+      when Patch
+        {"type" => "patch", "edits" => patch.edits.map do |edit|
+          {"old_start" => edit.old_range.begin, "old_end" => edit.old_range.end,
+            "new_start" => edit.new_range.begin, "new_end" => edit.new_range.end,
+            "old_text" => edit.old_text, "new_text" => edit.new_text}
+        end}
+      when Patch::Composite
+        {"type" => "composite", "patches" => patch.patches.map { |child| persistent_undo_patch(child) }}
+      else
+        raise Error, "unsupported persistent undo patch"
+      end
+    end
+
+    def persistent_undo_patch_before(data, after)
+      raise Error, "invalid persistent undo patch" unless data.is_a?(Hash)
+      case data.fetch("type")
+      when "patch"
+        edits = persistent_undo_edits(data.fetch("edits"))
+        inverse = edits.map { |edit| [edit.fetch(:new_range), edit.fetch(:old_text)] }
+        before = after.apply_edits(inverse)
+        changes = edits.map { |edit| [edit.fetch(:old_range), edit.fetch(:new_text)] }
+        patch = Patch.new(before, after, changes)
+        persistent_undo_verify_patch!(patch, edits)
+        [patch, before]
+      when "composite"
+        children = data.fetch("patches")
+        raise Error, "invalid persistent undo composite" unless children.is_a?(Array) && !children.empty?
+        current = after
+        patches = children.reverse_each.map do |child|
+          patch, before = persistent_undo_patch_before(child, current)
+          current = before
+          patch
+        end.reverse
+        [Patch::Composite.new(patches), current]
+      else
+        raise Error, "invalid persistent undo patch type"
+      end
+    end
+
+    def persistent_undo_edits(values)
+      raise Error, "invalid persistent undo edits" unless values.is_a?(Array) && !values.empty? && values.length <= 10_000
+      edits = values.map do |value|
+        raise Error, "invalid persistent undo edit" unless value.is_a?(Hash)
+        old_start, old_end, new_start, new_end = %w[old_start old_end new_start new_end].map { |key| value.fetch(key) }
+        old_text, new_text = value.fetch("old_text"), value.fetch("new_text")
+        valid = [old_start, old_end, new_start, new_end].all? { |number| number.is_a?(Integer) && number >= 0 } &&
+          old_start <= old_end && new_start <= new_end && old_text.is_a?(String) && new_text.is_a?(String) &&
+          old_text.bytesize == old_end - old_start && new_text.bytesize == new_end - new_start
+        raise Error, "invalid persistent undo edit" unless valid
+        {old_range: old_start...old_end, new_range: new_start...new_end, old_text: old_text, new_text: new_text}
+      end
+      edits.each_cons(2) do |left, right|
+        raise Error, "overlapping persistent undo edits" if left.fetch(:old_range).end > right.fetch(:old_range).begin || left.fetch(:new_range).end > right.fetch(:new_range).begin
+      end
+      edits
+    end
+
+    def persistent_undo_verify_patch!(patch, expected)
+      actual = patch.edits.map { |edit| {old_range: edit.old_range, new_range: edit.new_range, old_text: edit.old_text, new_text: edit.new_text} }
+      raise Error, "persistent undo patch mismatch" unless actual == expected
+      patch
+    end
+
+    def persistent_undo_selections(values, bytesize)
+      raise Error, "invalid persistent undo selections" unless values.is_a?(Array) && values.length <= 10_000
+      values.map do |value|
+        raise Error, "invalid persistent undo selection" unless value.is_a?(Hash)
+        id, anchor, head, goal = %w[id anchor head goal].map { |key| value.fetch(key) }
+        valid = id.is_a?(Integer) && anchor.is_a?(Integer) && head.is_a?(Integer) && anchor.between?(0, bytesize) && head.between?(0, bytesize) && (goal.nil? || goal.is_a?(Integer))
+        raise Error, "invalid persistent undo selection" unless valid
+        Selection.new(id, anchor, head, goal)
+      end.freeze
+    end
+
     def snapshot_line_ending(rope)
       return "\n" if rope.line_count < 2
       ending = rope.line_start(1)

data/lib/canopus/cli.rb

@@ -21,10 +21,11 @@ module Canopus
         flags.on("--profile JSON_PATH", "Save frame timings and sampled Ruby stacks on exit") { |value| options[:profile] = value }
         flags.on("--trace-allocations", "Trace live allocation sites (slow; requires --profile)") { options[:trace_allocations] = true }
         flags.on("--crash-report JSON_PATH", "Save exceptions locally; review before sharing") { |value| options[:crash_report] = value }
+        flags.on("--wait", "Wait until the opened files are closed") { options[:wait] = true }
         flags.on("--vim", "Enable Vim keybindings") { options[:vim] = true }
         flags.on("--plugin RUBY", "Load a Ruby plugin (requires --trust-plugins)") { |value| options[:plugins] << value }
         flags.on("--trust-plugins", "Allow the selected plugins to execute trusted Ruby code") { options[:trust_plugins] = true }
-        flags.on("--grant PERMISSION", Plugins::Registry::PERMISSIONS, "Grant a plugin API permission (repeatable)") { |value| options[:grants] << value }
+        flags.on("--grant PERMISSION", Plugins::PERMISSIONS, "Grant a plugin API permission (repeatable)") { |value| options[:grants] << value }
         flags.on("--plugins-in-process", "Run trusted plugins in the editor process") { options[:plugins_in_process] = true }
         flags.on("--version") { output.puts(VERSION); return 0 }
         flags.on("--help") { output.puts(flags); return 0 }
@@ -75,6 +76,8 @@ module Canopus
         workspace.performance = performance
       end
       controller = Controller.new(workspace, window)
+      controller.wait_for(files) if options[:wait] && !files.empty?
+      workspace.offer_recovery unless platform == :headless
       workspace.configure_text_system(cache_dir: options[:glyph_cache]) unless platform == :tui
       workspace.apply_settings
       warmup = Thread.new { window.text_system.prewarm(size: settings["font_size"]) } unless platform == :tui
@@ -148,7 +151,7 @@ module Canopus
     private_class_method :settle_export
 
     def self.finish_cli(options, workspace, window, performance, failure, error:)
-      operations = [-> { performance&.stop }, -> { workspace&.close },
+      operations = [-> { performance&.stop }, -> { workspace&.preserve_recovery! if failure; workspace&.close },
         -> { window&.on_close { true }; window&.close },
         -> { performance&.write(options[:profile]) }]
       operations.each do |operation|

data/lib/canopus/command.rb

@@ -11,15 +11,20 @@ module Canopus
       "tab.close_all" => {"cmd-alt-w" => "", "ctrl-alt-w" => ""}.freeze,
       "tab.reopen_closed" => {"cmd-shift-t" => "", "ctrl-shift-t" => ""}.freeze,
       "file.find" => {"cmd-p" => "", "ctrl-p" => ""}.freeze,
+      "language.workspace_symbols" => {"cmd-t" => "", "ctrl-t" => ""}.freeze,
       "command.palette" => {"cmd-shift-p" => "", "ctrl-shift-p" => ""}.freeze,
       "edit.undo" => {"cmd-z" => "", "ctrl-z" => ""}.freeze,
       "edit.redo" => {"cmd-shift-z" => "", "ctrl-shift-z" => ""}.freeze,
       "edit.select_all" => {"cmd-a" => "", "ctrl-a" => ""}.freeze,
       "edit.select_next" => {"cmd-d" => "", "ctrl-d" => ""}.freeze,
+      "edit.add_cursor_up" => {"ctrl-alt-up" => ""}.freeze,
+      "edit.add_cursor_down" => {"ctrl-alt-down" => ""}.freeze,
       "search.buffer" => {"cmd-f" => "", "ctrl-f" => ""}.freeze,
       "edit.select_all_occurrences" => {"cmd-shift-l" => "", "ctrl-shift-l" => ""}.freeze,
-      "edit.move_line_up" => {"alt-up" => ""}.freeze,
-      "edit.move_line_down" => {"alt-down" => ""}.freeze,
+      "edit.move_line_up" => {"alt-shift-up" => ""}.freeze,
+      "edit.move_line_down" => {"alt-shift-down" => ""}.freeze,
+      "language.expand_selection" => {"alt-up" => ""}.freeze,
+      "language.shrink_selection" => {"alt-down" => ""}.freeze,
       "search.project" => {"cmd-shift-f" => "", "ctrl-shift-f" => ""}.freeze,
       "search.replace" => {"cmd-alt-f" => "", "ctrl-h" => ""}.freeze,
       "edit.toggle_comment" => {"cmd-/" => "", "ctrl-/" => ""}.freeze,
@@ -33,13 +38,17 @@ module Canopus
       "language.codeAction" => {"alt-enter" => ""}.freeze,
       "language.outline" => {"cmd-shift-o" => "", "ctrl-shift-o" => ""}.freeze,
       "language.hover" => {"cmd-k" => "", "ctrl-k" => ""}.freeze,
+      "task.run" => {"cmd-shift-b" => "", "ctrl-shift-b" => ""}.freeze,
+      "task.stop" => {"ctrl-c" => "TaskOutput"}.freeze,
       "terminal.toggle" => {"ctrl-`" => "Terminal"}.freeze,
       "terminal.new" => {"ctrl-shift-`" => ""}.freeze,
       "terminal.close" => {"cmd-w" => "Terminal", "ctrl-w" => "Terminal"}.freeze,
-      "terminal.copy" => {"cmd-c" => "Terminal", "ctrl-shift-c" => "Terminal"}.freeze,
-      "terminal.paste" => {"cmd-v" => "Terminal", "ctrl-shift-v" => "Terminal"}.freeze,
+      "terminal.copy" => {"cmd-c" => "Terminal || TaskOutput", "ctrl-shift-c" => "Terminal || TaskOutput"}.freeze,
+      "terminal.paste" => {"cmd-v" => "Terminal || TaskOutput", "ctrl-shift-v" => "Terminal || TaskOutput"}.freeze,
       "terminal.next" => {"ctrl-shift-]" => "Terminal"}.freeze,
       "terminal.prev" => {"ctrl-shift-[" => "Terminal"}.freeze,
+      "terminal.command.previous" => {"ctrl-shift-up" => "Terminal"}.freeze,
+      "terminal.command.next" => {"ctrl-shift-down" => "Terminal"}.freeze,
       "terminal.clear" => {"cmd-k" => "Terminal"}.freeze,
       **(1..9).to_h { |index| ["terminal.select_#{index}", {"cmd-#{index}" => "Terminal"}.freeze] }
     }.freeze