aids 0.1.0 → 1.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 337b293a5ba264b783e5dfec4a325a55b64cfd518df952e9d64ab4ce558e06d3
-  data.tar.gz: 2788dcdd58c52f75802bd09cbbbaa7635f77c3c944822869519a006c125b7217
+  metadata.gz: e60e41121f7a2b87f9eabf7da50f3db77f1c39c29d92387aea3574a92e6879ad
+  data.tar.gz: 5530066dc015f810cf9c5e20c6d058e08349f380b7a0f7ea0267fea6ba1c2f8c
 SHA512:
-  metadata.gz: 4b4505c645ef91a032a84030807383f6754ee2d5775a728a327779f2fd63abc983e18ab5445e71083dafba39bf809f4e44294918a66616941ac3c44bcff02e5e
-  data.tar.gz: 55ab70c325977de42c7f1e03ff6b511fd4b47bb5c8563c2d95e2d1cb0f6ceba73bcbc28c467c6fa25fb342307f467cb67bdb6b6cb28afa95cb53607c23f6bec0
+  metadata.gz: db161e59e16a9a9fdb06a53bad67206e536d12093dd4b22b6f1fbc9fb9cba277ae5cbec3309d28b300e33cb6d1020fcb5ef4b0a82aae58a4dc0cef26480a86b9
+  data.tar.gz: 835b58458d85c051651a45f3574d24f6d80567d528666a4b5545331f2ea34ebcb05c9f704cd48e58328b9099a3e4b4ff8de0efde0d08ef820b9a86e9e2e3928b

data/lib/aids.rb

@@ -107,15 +107,16 @@ module AI
 
   # ── Entry point ──────────────────────────────────────────────────────
   def self.run(argv = ARGV)
-    resume = false
+    resume = false; temp = false
     rest = OptionParser.new { |o|
       o.on("-c", "--continue") { resume = true }
+      o.on("-t", "--temp") { temp = true }
       o.on("--history") { exec("lf", DATA_DIR) }
       o.on("--clean") { clean!; exit }
     }.order(argv)
 
     key = ENV["DEEPSEEK_API_KEY"] or abort "#{Ansi.fg(196)}DEEPSEEK_API_KEY not set#{Ansi.reset}"
-    app = App.new(key: key, profile: Profile.load, resume: resume)
+    app = App.new(key: key, profile: Profile.load, resume: resume, temp: temp)
 
     piped = $stdin.tty? ? "" : $stdin.read.strip
     text = [piped, rest.join(" ")].map(&:strip).reject(&:empty?).join(" ")

data/lib/ansi.rb

@@ -3,10 +3,10 @@ module AI
   module Ansi
     module_function
 
-    def reset    = "\e[0m"
-    def bold     = "\e[1m"
-    def dim      = "\e[2m"
-    def fg(n)    = "\e[38;5;#{n}m"
+    def reset = "\e[0m"
+    def bold = "\e[1m"
+    def dim = "\e[2m"
+    def fg(n) = "\e[38;5;#{n}m"
     def strip(s) = s.gsub(/\e\[[\d;]*m/, "")
 
     def width(s)

data/lib/app.rb

@@ -4,16 +4,16 @@ module AI
     TITLE_PROMPT = "Give a concise title (3-10 words) for this conversation. " \
                    "Respond with ONLY the title, nothing else."
 
-    DISCARD_USAGE = "usage: /discard [all | N | A-B | A- | -B]"
+    DISCARD_USAGE = "usage: /discard [* | N | A-B | A- | -B]"
 
     attr_reader :session, :attachments
 
-    def initialize(key:, profile:, resume: false)
-      @key = key; @profile = profile
+    def initialize(key:, profile:, resume: false, temp: false)
+      @key = key; @profile = profile; @temp = temp
       @editor = LineEditor.new
       @editor.completer = ->(prefix) { complete(prefix) }
-      @hl     = Highlighter.new
-      @fresh  = true
+      @hl = Highlighter.new
+      @fresh = true
       @attachments = []
       @title_thread = nil
       if resume && (st = Session.all.last) && (s = Session.load(st))
@@ -33,8 +33,7 @@ module AI
 
       print_attachments(attached_data) if attached_data.any?
       puts "\n#{Ansi.fg(p.color)}#{p.icon} #{p.name}#{Ansi.reset}"
-      reply, usage =
-        begin
+      reply, usage = begin
           AI.stream(pending, p.system, @key) { |chunk| print @hl.paint(chunk) }
         rescue Interrupt
           puts "\n#{Ansi.fg(220)}[interrupted — turn discarded]#{Ansi.reset}"
@@ -44,19 +43,18 @@ module AI
       @session.add_turn(text, reply, usage, attachments: attached_data)
       @attachments = []
       AI.print_usage(usage)
-      @session.save(p)
+      @session.save(p) unless @temp
       @fresh = false
-      Stats.record(usage)
-      kick_title_fetch if @session.title.nil? && @session.messages.length >= 2
+      Stats.record(usage) unless @temp
+      kick_title_fetch unless @temp
     end
 
     def discard(arg)
       arg = arg.to_s.strip
-      return discard_session if arg == "all"
+      return discard_session if arg == "*"
 
       total = @session.turns
-      range =
-        if arg.empty?
+      range = if arg.empty?
           [total, total]
         else
           parsed = parse_discard_arg(arg, total)
@@ -66,7 +64,7 @@ module AI
 
       first, last = range
       first = first.clamp(1, total)
-      last  = last.clamp(1, total)
+      last = last.clamp(1, total)
       if last < first
         notify "no turns in that range"; return
       end
@@ -78,7 +76,7 @@ module AI
         redraw
         notify "\u2212 discarded #{removed} turn#{removed == 1 ? "" : "s"} · session is now empty"
       else
-        @session.save(@profile)
+        @session.save(@profile) unless @temp
         redraw
         notify "\u2212 discarded #{removed} turn#{removed == 1 ? "" : "s"}"
       end
@@ -94,7 +92,7 @@ module AI
         return
       end
       @session.title = text
-      @session.save(@profile)
+      @session.save(@profile) unless @temp
       redraw
       notify "title set"
     end
@@ -104,12 +102,14 @@ module AI
       src = @session
       dup = Session.new
       dup.messages = Marshal.load(Marshal.dump(src.messages))
-      dup.usages   = Marshal.load(Marshal.dump(src.usages))
-      dup.title    = src.title ? "#{src.title} (clone)" : "(clone)"
-      dup.save(@profile)
-      FileUtils.cp(src.history_file, dup.history_file) if File.exist?(src.history_file)
+      dup.usages = Marshal.load(Marshal.dump(src.usages))
+      dup.title = src.title ? "#{src.title} (clone)" : "(clone)"
+      unless @temp
+        dup.save(@profile)
+        FileUtils.cp(src.history_file, dup.history_file) if File.exist?(src.history_file)
+      end
       @session = dup
-      @fresh   = false
+      @fresh = false
       load_history
       redraw
       notify "cloned to new session"
@@ -155,19 +155,19 @@ module AI
       end
       expanded = File.expand_path(arg)
       targets = if File.directory?(expanded)
-        @attachments.select { |p| File.dirname(p) == expanded }
-      else
-        exact = @attachments.find { |p| Paths.short(p) == arg }
-        if exact
-          [exact]
+          @attachments.select { |p| File.dirname(p) == expanded }
         else
-          @attachments.select { |p|
-            File.fnmatch(arg, File.basename(p)) ||
-            File.fnmatch(arg, Paths.short(p)) ||
-            File.fnmatch(arg, p)
-          }
+          exact = @attachments.find { |p| Paths.short(p) == arg }
+          if exact
+            [exact]
+          else
+            @attachments.select { |p|
+              File.fnmatch(arg, File.basename(p)) ||
+              File.fnmatch(arg, Paths.short(p)) ||
+              File.fnmatch(arg, p)
+            }
+          end
         end
-      end
       if targets.empty?
         notify "no matching attachments: #{arg}"
         return
@@ -187,12 +187,12 @@ module AI
       redraw if @session.messages.any?
       loop do
         puts format_attachment_summary if @attachments.any?
-        result = begin; @editor.readline(build_prompt); rescue Interrupt; break; end
+        result = begin; @editor.readline(build_prompt);           rescue Interrupt; break; end
         case result
-        when nil          then break
-        when :sess_next   then switch_session(+1)
-        when :sess_prev   then switch_session(-1)
-        when :redraw      then redraw
+        when nil then break
+        when :sess_next then switch_session(+1)
+        when :sess_prev then switch_session(-1)
+        when :redraw then redraw
         when :del_session then delete_session
         when String
           t = result.strip
@@ -251,10 +251,10 @@ module AI
     def complete(prefix)
       return nil unless Commands.slash?(prefix)
       if (m = prefix.match(/\A(\/\S+)\s+/))
-        name      = m[1]
+        name = m[1]
         arg_start = m.end(0)
-        arg       = prefix[arg_start..]
-        cmd       = Commands.find(name)
+        arg = prefix[arg_start..]
+        cmd = Commands.find(name)
         return nil unless cmd && cmd.available?(self) && cmd.arg_complete
         { matches: cmd.arg_complete.call(self, arg), start: arg_start }
       else
@@ -264,7 +264,7 @@ module AI
 
     def handle_command(input)
       case Commands.dispatch(self, input)
-      when :unknown     then notify "unknown command: #{input.split.first}"
+      when :unknown then notify "unknown command: #{input.split.first}"
       when :unavailable then notify "not available right now: #{input.split.first}"
       end
     end
@@ -279,7 +279,7 @@ module AI
 
     def center(str)
       cols = IO.console&.winsize&.last || 80
-      pad  = [(cols - Ansi.width(str)) / 2, 0].max
+      pad = [(cols - Ansi.width(str)) / 2, 0].max
       (" " * pad) + str
     end
 
@@ -368,7 +368,7 @@ module AI
     def draw_meta
       all = Session.all
       idx = all.index(@session.stamp)
-      n   = idx ? idx + 1 : all.length + 1
+      n = idx ? idx + 1 : all.length + 1
       total = [all.length, n].max
       puts center("#{CMT_STYLE}session #{n}/#{total}  \u00b7  #{@session.human_time}#{Ansi.reset}")
     end
@@ -406,7 +406,7 @@ module AI
     end
 
     def save_history
-      return if @editor.history.empty?
+      return if @temp || @editor.history.empty?
       FileUtils.mkdir_p(META_DIR)
       File.write(@session.history_file, @editor.history.last(1000).join("\n"))
     end

data/lib/commands.rb

@@ -9,11 +9,11 @@ module AI
 
     def self.register(name, desc:, available: nil, arg_complete: nil, &run)
       REGISTRY[name] = Command.new(
-        name: name, desc: desc, available: available, arg_complete: arg_complete, run: run
+        name: name, desc: desc, available: available, arg_complete: arg_complete, run: run,
       )
     end
 
-    def self.find(name)    = REGISTRY[name]
+    def self.find(name) = REGISTRY[name]
     def self.slash?(input) = input.start_with?("/")
 
     def self.available_names(app)
@@ -33,48 +33,42 @@ module AI
     end
 
     register("/discard",
-      desc: "Remove turn(s): /discard [all|N|A-B|A-|-B]",
-      available:    ->(app) { !app.session.empty? },
-      arg_complete: ->(_app, arg) { %w[all].select { |x| x.start_with?(arg) } }
-    ) do |app, args|
+             desc: "Remove turn(s): /discard [*|N|A-B|A-|-B]",
+             available: ->(app) { !app.session.empty? },
+             arg_complete: ->(_app, arg) { %w[*].select { |x| x.start_with?(arg) } }) do |app, args|
       app.discard(args)
     end
 
     register("/title",
-      desc: "Set the session title",
-      available: ->(app) { !app.session.empty? }
-    ) do |app, args|
+             desc: "Set the session title",
+             available: ->(app) { !app.session.empty? }) do |app, args|
       app.set_title(args.strip)
     end
 
     register("/clone",
-      desc: "Clone this session into a new active one",
-      available: ->(app) { !app.session.empty? }
-    ) do |app, _|
+             desc: "Clone this session into a new active one",
+             available: ->(app) { !app.session.empty? }) do |app, _|
       app.clone_session
     end
 
     register("/attach",
-      desc: "Attach a file or directory to the next turn",
-      arg_complete: ->(_app, arg) { Paths.complete(arg) }
-    ) do |app, args|
+             desc: "Attach a file or directory to the next turn",
+             arg_complete: ->(_app, arg) { Paths.complete(arg) }) do |app, args|
       app.attach(args.strip)
     end
 
     register("/detach",
-      desc: "Remove an attachment",
-      available:    ->(app) { app.attachments.any? },
-      arg_complete: ->(app, arg) {
-        app.attachments.map { |p| Paths.short(p) }.select { |s| s.start_with?(arg) }
-      }
-    ) do |app, args|
+             desc: "Remove an attachment",
+             available: ->(app) { app.attachments.any? },
+             arg_complete: ->(app, arg) {
+               app.attachments.map { |p| Paths.short(p) }.select { |s| s.start_with?(arg) }
+             }) do |app, args|
       app.detach(args.strip)
     end
 
     register("/files",
-      desc: "List currently attached files",
-      available: ->(app) { app.attachments.any? }
-    ) do |app, _|
+             desc: "List currently attached files",
+             available: ->(app) { app.attachments.any? }) do |app, _|
       app.list_files
     end
   end

data/lib/line_editor.rb

@@ -1,64 +1,70 @@
 module AI
-  # ── Mini line editor with history + Tab completion (with cycling) ────
+  # ── Mini line editor with history + Tab completion ───────────────────
   class LineEditor
     attr_accessor :history, :completer
 
     SIGNALS = {
-      "\ej"     => :sess_next,
-      "\ek"     => :sess_prev,
-      "\el"     => :redraw,  "\eL" => :redraw,
+      "\ej" => :sess_next,
+      "\ek" => :sess_prev,
+      "\el" => :redraw, "\eL" => :redraw,
       "\e[3;7~" => :del_session, "\e\e[3;5~" => :del_session,
-      "\e[3;5~" => :del_session, "\e\e[3^"   => :del_session,
-      "\e[3^"   => :del_session, "\e[3;8~"   => :del_session
+      "\e[3;5~" => :del_session, "\e\e[3^" => :del_session,
+      "\e[3^" => :del_session, "\e[3;8~" => :del_session,
     }.freeze
 
+    PASTE_STYLE = "\e[48;5;18;38;5;231m"
+    BPASTE_ON = "\e[?2004h"
+    BPASTE_OFF = "\e[?2004l"
+
     def initialize; @history = []; @completer = nil; end
 
     def readline(prompt)
-      @prompt = prompt; @buf = +""; @cur = 0
+      @prompt = prompt.to_s; @buf = +""; @cur = 0
       @hpos = @history.length; @stash = nil
-      @prev_rows = 0; @prev_cur_row = 0
+      @prev_rows = 1; @prev_cur_row = 0
       @cycle = nil
+      @pastes = []
+      print BPASTE_ON
       render
-      $stdin.raw do |io|
-        loop do
-          k = read_key(io) or next
-          if (sig = SIGNALS[k]) then return signal(sig) end
-          @cycle = nil unless k == "\t"
-          case k
-          when "\r", "\n" then return submit
-          when "\t"       then handle_tab
-          when "\x03" then end_render; print "\r\n"; raise Interrupt
-          when "\e[3~"
-            @buf.slice!(@cur); render if @cur < @buf.length
-          when "\x02", "\e[D" then move(-1)
-          when "\x06", "\e[C" then move(+1)
-          when "\x01", "\e[H", "\eOH", "\e[1~" then @cur = 0; render
-          when "\x05", "\e[F", "\eOF", "\e[4~" then @cur = @buf.length; render
-          when "\eb"  then @cur = word_back; render
-          when "\ef"  then @cur = word_fwd;  render
-          when "\x10", "\e[A" then history_step(-1)
-          when "\x0e", "\e[B" then history_step(+1)
-          when "\x7f", "\b", "\x08"
-            (@buf.slice!(@cur - 1); @cur -= 1; render) if @cur > 0
-          when "\x04"
-            if @buf.empty? then end_render; print "\r\n"; return nil
-            elsif @cur < @buf.length then @buf.slice!(@cur); render
+      begin
+        $stdin.raw do |io|
+          loop do
+            k = read_key(io) or next
+            if (sig = SIGNALS[k]) then return signal(sig) end
+            @cycle = nil unless k == "\t"
+            case k
+            when "\e[200~" then collect_paste(io)
+            when "\r", "\n" then insert("\n")
+            when "\e\r", "\e\n" then return submit
+            when "\t" then handle_tab
+            when "\x03" then end_render; print "\r\n"; raise Interrupt
+            when "\e[3~" then forward_delete
+            when "\x02", "\e[D" then move(-1)
+            when "\x06", "\e[C" then move(+1)
+            when "\x01", "\e[H", "\eOH", "\e[1~" then @cur = 0; render
+            when "\x05", "\e[F", "\eOF", "\e[4~" then @cur = @buf.length; render
+            when "\eb" then @cur = word_back; render
+            when "\ef" then @cur = word_fwd; render
+            when "\x10", "\e[A" then history_step(-1)
+            when "\x0e", "\e[B" then history_step(+1)
+            when "\x7f", "\b", "\x08" then backspace
+            when "\x04"
+              if @buf.empty? then end_render; print "\r\n"; return nil else forward_delete end
+            when "\x0b" then del_range(@cur, @buf.length); render
+            when "\x15" then del_range(0, @cur); render
+            when "\x17" then j = word_back; del_range(j, @cur); render
+            when "\ed" then j = word_fwd; del_range(@cur, j); render
+            when "\eu" then case_word(:upcase); render
+            when "\eU" then case_word(:downcase); render
+            when "\x14" then transpose; render
+            when "\x0c" then print "\e[H\e[2J"; @prev_rows = 0; @prev_cur_row = 0; render
+            when "\e" then nil
+            else insert(k) if printable?(k)
             end
-          when "\x0b" then @buf.slice!(@cur..);  render
-          when "\x15" then @buf.slice!(0...@cur); @cur = 0; render
-          when "\x17"
-            j = word_back; @buf.slice!(j...@cur); @cur = j; render
-          when "\ed"
-            j = word_fwd;  @buf.slice!(@cur...j); render
-          when "\eu" then case_word(:upcase);   render
-          when "\eU" then case_word(:downcase); render
-          when "\x14" then transpose; render
-          when "\x0c" then print "\e[H\e[2J"; @prev_rows = 0; @prev_cur_row = 0; render
-          when "\e"   then nil
-          else insert(k) if printable?(k)
           end
         end
+      ensure
+        print BPASTE_OFF
       end
     end
 
@@ -69,12 +75,13 @@ module AI
     def submit
       end_render
       print "\r\n"
-      @history << @buf.dup unless @buf.empty? || @buf == @history.last
-      @buf
+      out = @buf.dup
+      @history << out unless out.empty? || out == @history.last
+      out
     end
 
     def end_render
-      down = @prev_rows - 1 - @prev_cur_row
+      down = (@prev_rows - 1) - @prev_cur_row
       print "\e[#{down}B" if down > 0
       print "\r"
     end
@@ -87,38 +94,78 @@ module AI
 
     def printable?(k) = !k.start_with?("\e") && k.ord >= 32
 
-    def insert(k);  @buf.insert(@cur, k); @cur += k.length; render; end
+    # ── Buffer mutations (paste-aware) ───────────────────────────────
+
+    def insert(k)
+      @pastes.each { |p| p[:start] += k.length if p[:start] >= @cur }
+      @buf.insert(@cur, k)
+      @cur += k.length
+      render
+    end
+
+    def del_range(from, to)
+      from = [from, 0].max
+      to = [to, @buf.length].min
+      return if to <= from
+      len = to - from
+      @pastes.reject! { |p| p[:start] >= from && p[:start] + p[:length] <= to }
+      @pastes.each { |p| p[:start] -= len if p[:start] >= to }
+      @buf.slice!(from, len)
+      @cur = from if @cur > from && @cur < to
+      @cur -= len if @cur >= to
+    end
+
+    def backspace
+      return if @cur == 0
+      paste = @pastes.find { |p| @cur == p[:start] + p[:length] }
+      if paste
+        del_range(paste[:start], paste[:start] + paste[:length])
+      else
+        del_range(@cur - 1, @cur)
+      end
+      render
+    end
+
+    def forward_delete
+      return if @cur >= @buf.length
+      paste = @pastes.find { |p| @cur == p[:start] }
+      if paste
+        del_range(paste[:start], paste[:start] + paste[:length])
+      else
+        del_range(@cur, @cur + 1)
+      end
+      render
+    end
 
     def move(d)
       nc = @cur + d
-      (@cur = nc; render) if nc.between?(0, @buf.length)
+      return unless nc.between?(0, @buf.length)
+      paste = @pastes.find { |p| nc > p[:start] && nc < p[:start] + p[:length] }
+      nc = (d > 0 ? paste[:start] + paste[:length] : paste[:start]) if paste
+      @cur = nc; render
     end
 
+    # ── Tab completion ───────────────────────────────────────────────
+
     def handle_tab
       if @cycle
         @cycle[:index] = (@cycle[:index] + 1) % @cycle[:matches].length
-        apply_cycle
-        return
+        apply_cycle; return
       end
-
       return unless @completer
       prefix = @buf[0...@cur]
       result = @completer.call(prefix) or return
       matches, start = result[:matches], result[:start]
       return if matches.nil? || matches.empty?
-
       if matches.length == 1
-        replace_arg(start, matches[0])
-        return
+        replace_arg(start, matches[0]); return
       end
-
       common = matches.reduce do |a, b|
         i = 0
         i += 1 while i < a.length && i < b.length && a[i] == b[i]
         a[0...i]
       end
       current = prefix[start..]
-
       if common.length > current.length
         replace_arg(start, common)
       else
@@ -142,6 +189,8 @@ module AI
       render
     end
 
+    # ── Input reading ────────────────────────────────────────────────
+
     def read_key(io)
       b = io.getbyte or return nil
       return read_escape(io) if b == 27
@@ -162,12 +211,13 @@ module AI
         return "\e\e" unless IO.select([io], nil, nil, 0.05)
         c2 = io.getbyte or return "\e\e"
         c2 == 91 ? read_csi(io, +"\e\e[") : "\e\e#{c2.chr}"
+      when 13, 10 then "\e\r"
       else "\e#{c.chr}"
       end
     end
 
     def read_csi(io, buf)
-      12.times do
+      24.times do
         nb = io.getbyte or break
         buf << nb.chr
         break if nb.between?(64, 126)
@@ -175,32 +225,120 @@ module AI
       buf
     end
 
+    # ── Bracketed paste collection ───────────────────────────────────
+
+    def collect_paste(io)
+      terminator = "\e[201~".bytes
+      raw = +"".b
+      window = []
+      loop do
+        b = io.getbyte or break
+        window << b; window.shift if window.length > terminator.length
+        raw << b.chr
+        break if window == terminator
+      end
+      raw.slice!(-terminator.length, terminator.length) if raw.bytes.last(terminator.length) == terminator
+      text = raw.force_encoding("UTF-8").scrub
+      return if text.empty?
+      text = text.gsub("\r\n", "\n").tr("\r", "\n")
+      start = @cur
+      lines = text.count("\n") + 1
+      @pastes.each { |p| p[:start] += text.length if p[:start] >= @cur }
+      @buf.insert(@cur, text)
+      @pastes << { start: start, length: text.length, lines: lines }
+      @pastes.sort_by! { |p| p[:start] }
+      @cur = start + text.length
+      render
+    end
+
+    # ── Rendering ────────────────────────────────────────────────────
+
+    def paste_label_for(p)
+      n = p[:lines]
+      "#{PASTE_STYLE} #{n} #{n == 1 ? "line" : "lines"} pasted #{Ansi.reset}"
+    end
+
     def render
       cols = (IO.console&.winsize&.last || 80)
       cols = 1 if cols < 1
+
       print "\e[#{@prev_cur_row}A" if @prev_cur_row > 0
       print "\r\e[J"
-      print "#{@prompt}#{@buf}"
 
       prompt_w = Ansi.width(@prompt)
-      total_w  = prompt_w + Ansi.width(@buf)
-      cur_w    = prompt_w + Ansi.width(@buf[0...@cur] || "")
-      total_rows = total_w.zero? ? 1 : ((total_w - 1) / cols) + 1
-      end_row    = total_rows - 1
-      cur_row = cur_w / cols
-      cur_col = cur_w % cols
-      if cur_w.positive? && cur_w == total_w && cur_w % cols == 0
-        cur_row -= 1; cur_col = cols
+      indent = " " * prompt_w
+
+      out = +""
+      out << @prompt
+
+      row = 0
+      col = prompt_w
+      cur_row = 0
+      cur_col = prompt_w
+      cur_recorded = false
+
+      advance = lambda do |w|
+        col += w
+        while col >= cols
+          row += 1
+          col -= cols
+        end
+      end
+
+      newline_to_indent = lambda do
+        out << "\r\n" << indent
+        row += 1
+        col = prompt_w
       end
 
+      i = 0
+      while i <= @buf.length
+        if !cur_recorded && i == @cur
+          cur_row = row; cur_col = col; cur_recorded = true
+        end
+        break if i == @buf.length
+
+        paste = @pastes.find { |p| p[:start] == i }
+        if paste
+          newline_to_indent.call if col != prompt_w
+          label = paste_label_for(paste)
+          out << label
+          advance.call(Ansi.width(label))
+          i += paste[:length]
+          newline_to_indent.call
+          next
+        end
+
+        c = @buf[i]
+        if c == "\n"
+          newline_to_indent.call
+          i += 1
+          next
+        end
+
+        out << c
+        advance.call(Ansi.width(c))
+        i += 1
+      end
+
+      unless cur_recorded
+        cur_row = row; cur_col = col
+      end
+
+      print out
+
+      end_row = row
       print "\r"
       up = end_row - cur_row
-      print "\e[#{up}A"      if up > 0
+      print "\e[#{up}A" if up > 0
       print "\e[#{cur_col}C" if cur_col > 0
-      @prev_rows    = total_rows
+
+      @prev_rows = end_row + 1
       @prev_cur_row = cur_row
     end
 
+    # ── History / word ops ───────────────────────────────────────────
+
     def history_step(d)
       return if @history.empty?
       @stash = @buf.dup if @hpos == @history.length
@@ -208,6 +346,7 @@ module AI
       return if np == @hpos
       @hpos = np
       @buf = (@hpos == @history.length ? (@stash || +"") : @history[@hpos]).dup
+      @pastes = []
       @cur = @buf.length; render
     end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: aids
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.0.3
 platform: ruby
 authors:
 - emanrdesu