aids 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 337b293a5ba264b783e5dfec4a325a55b64cfd518df952e9d64ab4ce558e06d3
+  data.tar.gz: 2788dcdd58c52f75802bd09cbbbaa7635f77c3c944822869519a006c125b7217
+SHA512:
+  metadata.gz: 4b4505c645ef91a032a84030807383f6754ee2d5775a728a327779f2fd63abc983e18ab5445e71083dafba39bf809f4e44294918a66616941ac3c44bcff02e5e
+  data.tar.gz: 55ab70c325977de42c7f1e03ff6b511fd4b47bb5c8563c2d95e2d1cb0f6ceba73bcbc28c467c6fa25fb342307f467cb67bdb6b6cb28afa95cb53607c23f6bec0

data/bin/aids

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+$stdout.sync = true
+require "aids"
+AI.run

data/lib/aids.rb

@@ -0,0 +1,137 @@
+%w[net/http uri json optparse fileutils io/console pathname time emanlib].each { |lib| require lib }
+
+module AI
+  VERSION = "0.1.0"
+  API_URL = URI("https://api.deepseek.com/chat/completions")
+  MODEL = "deepseek-chat"
+  DATA_DIR = File.expand_path("~/.local/share/ai")
+  META_DIR = File.join(DATA_DIR, ".meta")
+  STATS_FILE = File.join(META_DIR, "stats.json")
+  RATES = { hit: 0.028, miss: 0.28, out: 0.42 }.freeze
+
+  LCAP = "\ue0b6"; RCAP = "\ue0b4"; USER_ICON = "👤"
+  USER_FG = 117; ATT_FG = 180; CMT_FG = 247
+  CMT_STYLE = "\e[2;3;38;5;#{CMT_FG}m"
+end
+
+require "profile"
+require "ansi"
+require "paths"
+require "highlighter"
+require "stats"
+require "session"
+require "commands"
+require "line_editor"
+require "app"
+
+module AI
+  # ── HTTP / streaming ─────────────────────────────────────────────────
+  def self.stream(messages, system, key)
+    body = { model: MODEL,
+             messages: [{ role: "system", content: system }, *messages],
+             stream: true,
+             stream_options: { include_usage: true } }.to_json
+    usage = nil
+    full = +""
+    Net::HTTP.start(API_URL.host, API_URL.port, use_ssl: true, read_timeout: 120) do |http|
+      req = Net::HTTP::Post.new(API_URL,
+                                "Authorization" => "Bearer #{key}",
+                                "Content-Type" => "application/json")
+      req.body = body
+      http.request(req) do |res|
+        abort "#{Ansi.fg(196)}API #{res.code}#{Ansi.reset}" unless res.is_a?(Net::HTTPSuccess)
+        buf = +""
+        res.read_body do |chunk|
+          buf << chunk
+          while (nl = buf.index("\n"))
+            line = buf.slice!(0..nl).strip
+            next unless line.start_with?("data: ")
+            payload = line.delete_prefix("data: ")
+            next if payload == "[DONE]"
+            event = JSON.parse(payload) rescue next
+            usage = event["usage"] if event["usage"]
+            if (tok = event.dig("choices", 0, "delta", "content"))
+              full << tok
+              yield tok
+            end
+          end
+        end
+      end
+    end
+    [full, usage]
+  end
+
+  def self.title_query(system, user, key)
+    body = { model: MODEL, max_tokens: 40,
+            messages: [{ role: "system", content: system },
+                       { role: "user", content: user }] }.to_json
+    Net::HTTP.start(API_URL.host, API_URL.port, use_ssl: true, read_timeout: 15) do |http|
+      req = Net::HTTP::Post.new(API_URL,
+                                "Authorization" => "Bearer #{key}",
+                                "Content-Type" => "application/json")
+      req.body = body
+      res = http.request(req)
+      return nil unless res.is_a?(Net::HTTPSuccess)
+      (JSON.parse(res.body) rescue nil)&.dig("choices", 0, "message", "content")&.strip
+    end
+  rescue StandardError
+    nil
+  end
+
+  def self.print_usage(usage)
+    return unless usage
+    g = "#{Ansi.dim}#{Ansi.fg(243)}"; r = Ansi.reset
+    cells = %w[hit miss out total].zip([
+      usage["prompt_cache_hit_tokens"] || 0,
+      usage["prompt_cache_miss_tokens"] || 0,
+      usage["completion_tokens"] || 0,
+      usage["total_tokens"] || 0,
+    ]).map { |label, val| "#{g}#{label}#{r} #{Ansi.fg(87)}#{val}#{r}" }
+    cells << "#{Ansi.fg(220)}#{format("%.4f", Stats.cost(usage))}\u03bc$#{r}"
+    row = "  #{cells.join("  #{g}\u2502#{r}  ")}  "
+    w = Ansi.width(row)
+    puts "\n#{g}\u256d#{"─" * w}\u256e#{r}"
+    puts "#{g}\u2502#{r}#{row}#{g}\u2502#{r}"
+    puts "#{g}\u2570#{"─" * w}\u256f#{r}"
+    puts
+  end
+
+  def self.api_message(msg)
+    if msg["role"] == "user" && (atts = msg["attachments"]) && atts.any?
+      blocks = atts.map { |a| "<attached path=\"#{a["path"]}\">\n#{a["content"]}\n</attached>" }
+      { "role" => "user", "content" => blocks.join("\n") + "\n\n" + msg["content"].to_s }
+    else
+      { "role" => msg["role"], "content" => msg["content"] }
+    end
+  end
+
+  # ── Entry point ──────────────────────────────────────────────────────
+  def self.run(argv = ARGV)
+    resume = false
+    rest = OptionParser.new { |o|
+      o.on("-c", "--continue") { resume = 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)
+
+    piped = $stdin.tty? ? "" : $stdin.read.strip
+    text = [piped, rest.join(" ")].map(&:strip).reject(&:empty?).join(" ")
+
+    if text.empty?
+      app.repl
+    else
+      puts "#{Ansi.dim}> #{text}#{Ansi.reset}"
+      app.ask(text); puts
+    end
+  end
+
+  def self.clean!
+    files = Dir[File.join(DATA_DIR, "*.md")] +
+            Dir[File.join(META_DIR, "*")].select { |x| File.file?(x) }
+    files.each { |f| File.delete(f) }
+    puts "#{Ansi.fg(114)}\u2726 #{files.size} files removed#{Ansi.reset}"
+  end
+end

data/lib/ansi.rb

@@ -0,0 +1,25 @@
+module AI
+  # ── ANSI helpers ─────────────────────────────────────────────────────
+  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 strip(s) = s.gsub(/\e\[[\d;]*m/, "")
+
+    def width(s)
+      strip(s).each_char.sum do |c|
+        case c.ord
+        when 0..126, 57344..63743 then 1
+        when 65024..65039, 8205 then 0
+        when 4352..4447, 9000..9215, 9728..9983, 11088..11093, 11904..40959,
+             44032..55215, 63744..64255, 65040..65135, 65281..65376,
+             127744..131071, 131072..262143 then 2
+        else 1
+        end
+      end
+    end
+  end
+end

data/lib/app.rb

@@ -0,0 +1,421 @@
+module AI
+  # ── App / REPL ───────────────────────────────────────────────────────
+  class App
+    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]"
+
+    attr_reader :session, :attachments
+
+    def initialize(key:, profile:, resume: false)
+      @key = key; @profile = profile
+      @editor = LineEditor.new
+      @editor.completer = ->(prefix) { complete(prefix) }
+      @hl     = Highlighter.new
+      @fresh  = true
+      @attachments = []
+      @title_thread = nil
+      if resume && (st = Session.all.last) && (s = Session.load(st))
+        @session = s; @fresh = false
+      end
+      @session ||= Session.new
+    end
+
+    def ask(text)
+      p = @profile
+      attached_data = @attachments.map { |abs|
+        { "path" => Paths.short(abs), "content" => safe_read(abs) }
+      }
+      user_msg = { "role" => "user", "content" => text }
+      user_msg["attachments"] = attached_data unless attached_data.empty?
+      pending = @session.messages.map { |m| AI.api_message(m) } << AI.api_message(user_msg)
+
+      print_attachments(attached_data) if attached_data.any?
+      puts "\n#{Ansi.fg(p.color)}#{p.icon} #{p.name}#{Ansi.reset}"
+      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}"
+          return
+        end
+      puts
+      @session.add_turn(text, reply, usage, attachments: attached_data)
+      @attachments = []
+      AI.print_usage(usage)
+      @session.save(p)
+      @fresh = false
+      Stats.record(usage)
+      kick_title_fetch if @session.title.nil? && @session.messages.length >= 2
+    end
+
+    def discard(arg)
+      arg = arg.to_s.strip
+      return discard_session if arg == "all"
+
+      total = @session.turns
+      range =
+        if arg.empty?
+          [total, total]
+        else
+          parsed = parse_discard_arg(arg, total)
+          return notify(DISCARD_USAGE) unless parsed
+          parsed
+        end
+
+      first, last = range
+      first = first.clamp(1, total)
+      last  = last.clamp(1, total)
+      if last < first
+        notify "no turns in that range"; return
+      end
+
+      removed = @session.remove_turns(first, last)
+      if @session.empty?
+        @session.delete_files
+        @fresh = true
+        redraw
+        notify "\u2212 discarded #{removed} turn#{removed == 1 ? "" : "s"} · session is now empty"
+      else
+        @session.save(@profile)
+        redraw
+        notify "\u2212 discarded #{removed} turn#{removed == 1 ? "" : "s"}"
+      end
+    end
+
+    def discard_session
+      delete_session(announce: "discarded session #{@session.stamp}")
+    end
+
+    def set_title(text)
+      if text.empty?
+        notify "usage: /title <new title>"
+        return
+      end
+      @session.title = text
+      @session.save(@profile)
+      redraw
+      notify "title set"
+    end
+
+    def clone_session
+      save_history
+      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)
+      @session = dup
+      @fresh   = false
+      load_history
+      redraw
+      notify "cloned to new session"
+    end
+
+    def attach(arg)
+      if arg.empty?
+        notify "usage: /attach <file-or-directory-or-pattern>"
+        return
+      end
+      matches = Dir.glob(arg).map { |p| File.expand_path(p) }
+      if matches.empty?
+        expanded = File.expand_path(arg)
+        if File.exist?(expanded)
+          matches = [expanded]
+        else
+          notify "no such path: #{arg}"
+          return
+        end
+      end
+      files = []
+      matches.each do |p|
+        if File.directory?(p)
+          files.concat(Dir.children(p).map { |c| File.join(p, c) }.select { |cp| File.file?(cp) })
+        elsif File.file?(p)
+          files << p
+        end
+      end
+      added = files.uniq - @attachments
+      if added.empty?
+        notify "(nothing new to attach)"
+        return
+      end
+      @attachments.concat(added)
+      shorts = added.map { |p| Paths.short(p) }
+      notify "+ attached #{shorts.join(", ")}"
+    end
+
+    def detach(arg)
+      if arg.empty?
+        notify "usage: /detach <path|pattern|directory>"
+        return
+      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]
+        else
+          @attachments.select { |p|
+            File.fnmatch(arg, File.basename(p)) ||
+            File.fnmatch(arg, Paths.short(p)) ||
+            File.fnmatch(arg, p)
+          }
+        end
+      end
+      if targets.empty?
+        notify "no matching attachments: #{arg}"
+        return
+      end
+      targets.each { |t| @attachments.delete(t) }
+      shorts = targets.map { |p| Paths.short(p) }
+      notify "\u2212 detached #{shorts.join(", ")}"
+    end
+
+    def list_files
+      shorts = @attachments.map { |p| Paths.short(p) }
+      notify "#{@attachments.length} file(s) attached:\n#{shorts.join("\n")}"
+    end
+
+    def repl
+      load_history
+      redraw if @session.messages.any?
+      loop do
+        puts format_attachment_summary if @attachments.any?
+        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 :del_session then delete_session
+        when String
+          t = result.strip
+          next if t.empty?
+          break if %w[exit quit bye :q].include?(t)
+          if Commands.slash?(t)
+            handle_command(t)
+          else
+            @hl = Highlighter.new
+            ask(t); puts
+          end
+        end
+      end
+      flush_title_fetch
+      save_history
+      footer
+    end
+
+    def notify(msg) = puts("#{CMT_STYLE}#{msg}#{Ansi.reset}\n\n")
+
+    def format_attachment_summary
+      return nil if @attachments.empty?
+      counts = @attachments.group_by { |p| File.extname(p).delete_prefix(".") }
+      parts = counts.sort_by { |ext, _| ext }.map do |ext, fs|
+        ext_display = ext.empty? ? "(no ext)" : ext
+        "#{fs.length} #{ext_display}"
+      end
+      suffix = counts.length == 1 ? " file included" : " file(s) included"
+      "\e[2;38;5;75m#{parts.join(", ")}#{suffix}\e[0m"
+    end
+
+    private
+
+    def parse_discard_arg(arg, total)
+      case arg
+      when /\A(\d+)\z/
+        n = $1.to_i
+        return nil if n < 1
+        n = [n, total].min
+        [total - n + 1, total]
+      when /\A(\d+)-(\d+)\z/
+        a, b = $1.to_i, $2.to_i
+        return nil if a < 1 || b < a
+        [a, b]
+      when /\A(\d+)-\z/
+        a = $1.to_i
+        return nil if a < 1
+        [a, total]
+      when /\A-(\d+)\z/
+        n = $1.to_i
+        return nil if n < 1
+        [1, n]
+      end
+    end
+
+    def complete(prefix)
+      return nil unless Commands.slash?(prefix)
+      if (m = prefix.match(/\A(\/\S+)\s+/))
+        name      = m[1]
+        arg_start = m.end(0)
+        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
+        { matches: Commands.complete_name(self, prefix), start: 0 }
+      end
+    end
+
+    def handle_command(input)
+      case Commands.dispatch(self, input)
+      when :unknown     then notify "unknown command: #{input.split.first}"
+      when :unavailable then notify "not available right now: #{input.split.first}"
+      end
+    end
+
+    def safe_read(path)
+      File.read(path, mode: "rb").force_encoding("UTF-8").scrub
+    rescue StandardError => e
+      "[could not read #{path}: #{e.message}]"
+    end
+
+    def clear_screen = print("\e[H\e[2J\e[3J")
+
+    def center(str)
+      cols = IO.console&.winsize&.last || 80
+      pad  = [(cols - Ansi.width(str)) / 2, 0].max
+      (" " * pad) + str
+    end
+
+    def print_attachments(attached)
+      puts "#{Ansi.dim}#{Ansi.fg(ATT_FG)}📎 attached#{Ansi.reset}"
+      attached.each { |a| puts "  #{Ansi.fg(ATT_FG)}#{a["path"]}#{Ansi.reset}" }
+    end
+
+    def delete_session(announce: nil)
+      stamp = @session.stamp
+      save_history
+      all = Session.all
+      idx = all.index(stamp)
+      @session.delete_files
+
+      remaining = Session.all
+      target = idx && idx > 0 ? remaining[idx - 1] : remaining.first
+      if target && (s = Session.load(target))
+        @session = s; @fresh = false
+        load_history; redraw
+      else
+        @fresh = true
+        @session = Session.new
+        @editor.history = []
+        clear_screen
+      end
+      notify(announce || "deleted session #{stamp}")
+    end
+
+    def switch_session(dir)
+      save_history
+      all = Session.all
+
+      if @fresh
+        return unless dir < 0 && all.any?
+        @fresh = false
+        @session = Session.load(all.last) or return
+        load_history; redraw
+        return
+      end
+
+      return if all.empty?
+      cur = all.index(@session.stamp) or return
+      target = cur + dir
+      if target >= all.length
+        @fresh = true
+        @session = Session.new
+        @editor.history = []
+        clear_screen
+        return
+      end
+      target = target.clamp(0, all.length - 1)
+      return if target == cur
+      @session = Session.load(all[target]) or return
+      load_history; redraw
+    end
+
+    def redraw
+      clear_screen
+      draw_title; draw_meta
+      puts
+      p = @profile
+      @session.messages.each do |m|
+        if m["role"] == "user"
+          puts "#{Ansi.bold}#{Ansi.fg(USER_FG)}#{USER_ICON}  #{m["content"]}#{Ansi.reset}"
+          print_attachments(m["attachments"]) if m["attachments"]&.any?
+        else
+          puts "#{Ansi.fg(p.color)}#{p.icon} #{p.name}#{Ansi.reset}"
+          print Highlighter.new.paint(m["content"]); puts
+        end
+        puts
+      end
+      print_attachments(@attachments.map { |p| { "path" => Paths.short(p) } }) if @attachments.any?
+    end
+
+    def draw_title
+      return unless @session.title
+      e = Ansi.fg(@profile.color)
+      inner = "  #{@session.title}  "
+      w = Ansi.width(inner)
+      puts center("#{e}\u256d#{"─" * w}\u256e#{Ansi.reset}")
+      puts center("#{e}\u2502#{Ansi.reset}#{inner}#{e}\u2502#{Ansi.reset}")
+      puts center("#{e}\u2570#{"─" * w}\u256f#{Ansi.reset}")
+    end
+
+    def draw_meta
+      all = Session.all
+      idx = all.index(@session.stamp)
+      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
+
+    def kick_title_fetch
+      return if @title_thread&.alive?
+      session = @session; profile = @profile; key = @key
+      context = session.messages.first(2)
+                       .map { |m| "#{m["role"]}: #{m["content"]}" }.join("\n\n")
+      @title_thread = Thread.new do
+        Thread.current.report_on_exception = false
+        title = AI.title_query(TITLE_PROMPT, context, key)
+        if title && session.title.nil?
+          session.title = title
+          session.save(profile) if File.exist?(session.json_file)
+        end
+      end
+    end
+
+    def flush_title_fetch
+      @title_thread&.join(2.second) rescue nil
+    end
+
+    def build_prompt
+      p = @profile; c = p.color
+      turn = @session.turns + 1
+      label = " #{p.icon} #{p.name} \u00b7#{turn} "
+      "\e[38;5;#{c}m#{LCAP}\e[48;5;#{c};38;5;0m#{label}\e[0;38;5;#{c}m#{RCAP}\e[0m " \
+      "\e[2;38;5;#{c}m#{p.prompt}\e[0m "
+    end
+
+    def load_history
+      f = @session.history_file
+      @editor.history = File.exist?(f) ? File.readlines(f, chomp: true).last(500) : []
+    end
+
+    def save_history
+      return if @editor.history.empty?
+      FileUtils.mkdir_p(META_DIR)
+      File.write(@session.history_file, @editor.history.last(1000).join("\n"))
+    end
+
+    def footer
+      return if @session.messages.empty?
+      all = Session.all
+      n = (all.index(@session.stamp) || all.length - 1) + 1
+      puts "\n#{CMT_STYLE}session ##{n}#{Ansi.reset}"
+    end
+  end
+end

data/lib/commands.rb

@@ -0,0 +1,81 @@
+module AI
+  # ── Slash commands ───────────────────────────────────────────────────
+  module Commands
+    Command = Struct.new(:name, :desc, :available, :arg_complete, :run, keyword_init: true) do
+      def available?(app) = available.nil? || available.call(app)
+    end
+
+    REGISTRY = {}
+
+    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
+      )
+    end
+
+    def self.find(name)    = REGISTRY[name]
+    def self.slash?(input) = input.start_with?("/")
+
+    def self.available_names(app)
+      REGISTRY.values.select { |c| c.available?(app) }.map(&:name).sort
+    end
+
+    def self.complete_name(app, prefix)
+      available_names(app).select { |n| n.start_with?(prefix) }
+    end
+
+    def self.dispatch(app, input)
+      name, rest = input.strip.split(/\s+/, 2)
+      cmd = REGISTRY[name] or return :unknown
+      return :unavailable unless cmd.available?(app)
+      cmd.run.call(app, rest || "")
+      :ok
+    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|
+      app.discard(args)
+    end
+
+    register("/title",
+      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, _|
+      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|
+      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|
+      app.detach(args.strip)
+    end
+
+    register("/files",
+      desc: "List currently attached files",
+      available: ->(app) { app.attachments.any? }
+    ) do |app, _|
+      app.list_files
+    end
+  end
+end

data/lib/highlighter.rb

@@ -0,0 +1,171 @@
+module AI
+  # ── Streaming syntax highlighter ─────────────────────────────────────
+  class Highlighter
+    R = "\e[0m"
+    OPENERS = { "(" => ")", "[" => "]", "{" => "}" }.freeze
+    CLOSERS = OPENERS.invert.freeze
+    PINK   = [255, 128, 170].freeze
+    PURPLE = [204, 153, 255].freeze
+    SALMON = [250, 128, 114].freeze
+    BROWN  = [196, 168, 130].freeze
+    BG     = [40, 42, 54].freeze
+    TAG_DELIM = "38;2;170;255;220"
+    TAG_NAME  = "38;2;200;240;215"
+    STRING    = "38;2;195;255;195"
+    NUM_FG = 183
+    SYMS = { ":" => 159, ";" => 159, "@" => 229, "^" => 229, "&" => 229,
+             "*" => 229, "-" => 180, "+" => 180, "." => 180, "," => 180,
+             "!" => 210, "~" => 217, "'" => 217 }.freeze
+
+    def initialize
+      @col = 0; @at_line_start = true
+      @mode = nil
+      @slash = false; @star = false
+      @in_string = false; @escape = false
+      @brackets = []; @in_word = false
+      @tag_state = nil; @tag_buf = +""; @tag_width = 0
+    end
+
+    def paint(text)
+      out = +""
+      text.each_char do |c|
+        if c == "\n" then out << newline
+        else out << paint_char(c); @col += 1
+        end
+      end
+      out
+    end
+
+    private
+
+    def newline
+      if @tag_state == :markup
+        @tag_state = nil; @tag_buf = +""; @tag_width = 0
+      end
+      @mode = nil if @mode == :line_comment
+      @slash = @star = false
+      @in_word = @in_string = @escape = false
+      @col = 0; @at_line_start = true
+      "\n"
+    end
+
+    def paint_char(c)
+      if @mode == :block_comment
+        out = "#{CMT_STYLE}#{c}#{R}"
+        if @star && c == "/" then @mode = nil; @star = false
+        else @star = (c == "*")
+        end
+        return out
+      end
+
+      return "#{CMT_STYLE}#{c}#{R}" if @mode == :line_comment
+
+      if @in_string
+        out = "\e[#{STRING}m#{c}#{R}"
+        if @escape then @escape = false
+        elsif c == "\\" then @escape = true
+        elsif c == '"' then @in_string = false
+        end
+        return out
+      end
+
+      if @slash
+        @slash = false
+        return case c
+               when "/" then @mode = :line_comment;  "\b \b#{CMT_STYLE}//#{R}"
+               when "*" then @mode = :block_comment; "\b \b#{CMT_STYLE}/*#{R}"
+               else "\b \b\e[38;5;229m/#{R}" << paint_char(c)
+               end
+      end
+
+      return paint_in_tag(c) if @tag_state == :markup
+
+      was_at_line_start = @at_line_start
+      @at_line_start = was_at_line_start && !!c.match?(/\s/)
+
+      if c == '"'
+        @in_string = true; @in_word = false
+        return "\e[#{STRING}m\"#{R}"
+      end
+      if c == "/"  then @slash = true; return "/" end
+      if c == "#"  then @mode = :line_comment; return "#{CMT_STYLE}##{R}" end
+      if c == ";" && was_at_line_start
+        @mode = :line_comment; return "#{CMT_STYLE};#{R}"
+      end
+
+      if @tag_state == :attrs
+        if c == ">" then @tag_state = nil; return "\e[#{TAG_DELIM}m>#{R}" end
+        return "\e[#{TAG_DELIM}m/#{R}" if c == "/"
+      end
+
+      if c == "<" && @tag_state.nil?
+        @tag_state = :markup; @tag_buf = +"<"; @tag_width = 1
+        @in_word = false
+        return "<"
+      end
+
+      if OPENERS[c]
+        clr = bracket_color(@col, @brackets.length)
+        @brackets.push(clr); @in_word = false
+        return "\e[38;2;#{clr}m#{c}#{R}"
+      end
+      if CLOSERS[c]
+        clr = @brackets.pop || bracket_color(@col, 0)
+        @in_word = false
+        return "\e[38;2;#{clr}m#{c}#{R}"
+      end
+
+      return (@in_word = true; c) if c.match?(/[A-Za-z_]/)
+      return (@in_word ? c : "\e[38;5;#{NUM_FG}m#{c}#{R}") if c.match?(/\d/)
+
+      @in_word = false
+      (sc = SYMS[c]) ? "\e[38;5;#{sc}m#{c}#{R}" : c
+    end
+
+    def paint_in_tag(c)
+      if @tag_buf == "<" && c == "/"
+        @tag_buf << c; @tag_width += 1; return c
+      end
+      name_started = @tag_buf.match?(%r{\A</?[A-Za-z]})
+      if c.match?(/[A-Za-z]/) || (name_started && c.match?(/[\w\-]/))
+        @tag_buf << c; @tag_width += 1; return c
+      end
+      return abort_tag(c) unless name_started
+
+      case c
+      when ">"
+        s = render_tag << "\e[#{TAG_DELIM}m>#{R}"
+        @tag_state = nil; @tag_buf = +""; @tag_width = 0; s
+      when "/", /\s/
+        s = render_tag
+        @tag_state = :attrs; @tag_buf = +""; @tag_width = 0
+        s << (c == "/" ? "\e[#{TAG_DELIM}m/#{R}" : c)
+      else abort_tag(c)
+      end
+    end
+
+    def render_tag
+      erase = "\b" * @tag_width
+      colored = @tag_buf.each_char.map { |c|
+        style = %w[< / >].include?(c) ? TAG_DELIM : TAG_NAME
+        "\e[#{style}m#{c}#{R}"
+      }.join
+      +"" << erase << (" " * @tag_width) << erase << colored
+    end
+
+    def abort_tag(c)
+      @tag_state = nil; @tag_buf = +""; @tag_width = 0
+      paint_char(c)
+    end
+
+    def bracket_color(col, depth)
+      t = ([col / 80.0, 1].min + [depth / 5.0, 1].min) / 2.0
+      o = [1 - depth * 0.08, 0.55].max
+      warm = (depth * 13 + col * 7) % 4 == 0
+      a, b = warm ? [SALMON, BROWN] : [PINK, PURPLE]
+      a.zip(b, BG).map { |fa, fb, bg|
+        (bg + ((fa + (fb - fa) * t).round - bg) * o).round
+      }.join(";")
+    end
+  end
+end

data/lib/line_editor.rb

@@ -0,0 +1,242 @@
+module AI
+  # ── Mini line editor with history + Tab completion (with cycling) ────
+  class LineEditor
+    attr_accessor :history, :completer
+
+    SIGNALS = {
+      "\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
+    }.freeze
+
+    def initialize; @history = []; @completer = nil; end
+
+    def readline(prompt)
+      @prompt = prompt; @buf = +""; @cur = 0
+      @hpos = @history.length; @stash = nil
+      @prev_rows = 0; @prev_cur_row = 0
+      @cycle = nil
+      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
+            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
+      end
+    end
+
+    private
+
+    def signal(s); clear_render; s; end
+
+    def submit
+      end_render
+      print "\r\n"
+      @history << @buf.dup unless @buf.empty? || @buf == @history.last
+      @buf
+    end
+
+    def end_render
+      down = @prev_rows - 1 - @prev_cur_row
+      print "\e[#{down}B" if down > 0
+      print "\r"
+    end
+
+    def clear_render
+      print "\e[#{@prev_cur_row}A" if @prev_cur_row > 0
+      print "\r\e[J"
+      @prev_rows = 0; @prev_cur_row = 0
+    end
+
+    def printable?(k) = !k.start_with?("\e") && k.ord >= 32
+
+    def insert(k);  @buf.insert(@cur, k); @cur += k.length; render; end
+
+    def move(d)
+      nc = @cur + d
+      (@cur = nc; render) if nc.between?(0, @buf.length)
+    end
+
+    def handle_tab
+      if @cycle
+        @cycle[:index] = (@cycle[:index] + 1) % @cycle[:matches].length
+        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
+      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
+        @cycle = { matches: matches, start: start, suffix: @buf[@cur..] || "", index: 0 }
+        apply_cycle
+      end
+    end
+
+    def replace_arg(start, text)
+      prefix = @buf[0...@cur]
+      @buf = prefix[0...start] + text + (@buf[@cur..] || "")
+      @cur = start + text.length
+      render
+    end
+
+    def apply_cycle
+      c = @cycle
+      match = c[:matches][c[:index]]
+      @buf = @buf[0...c[:start]] + match + c[:suffix]
+      @cur = c[:start] + match.length
+      render
+    end
+
+    def read_key(io)
+      b = io.getbyte or return nil
+      return read_escape(io) if b == 27
+      return b.chr if b < 128
+      n = b < 224 ? 2 : b < 240 ? 3 : 4
+      bytes = [b]
+      (n - 1).times { bytes << (io.getbyte || 0) }
+      bytes.pack("C*").force_encoding("UTF-8")
+    end
+
+    def read_escape(io)
+      return "\e" unless IO.select([io], nil, nil, 0.05)
+      c = io.getbyte or return "\e"
+      case c
+      when 91 then read_csi(io, +"\e[")
+      when 79 then "\eO#{(io.getbyte || 0).chr}"
+      when 27
+        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}"
+      else "\e#{c.chr}"
+      end
+    end
+
+    def read_csi(io, buf)
+      12.times do
+        nb = io.getbyte or break
+        buf << nb.chr
+        break if nb.between?(64, 126)
+      end
+      buf
+    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
+      end
+
+      print "\r"
+      up = end_row - cur_row
+      print "\e[#{up}A"      if up > 0
+      print "\e[#{cur_col}C" if cur_col > 0
+      @prev_rows    = total_rows
+      @prev_cur_row = cur_row
+    end
+
+    def history_step(d)
+      return if @history.empty?
+      @stash = @buf.dup if @hpos == @history.length
+      np = (@hpos + d).clamp(0, @history.length)
+      return if np == @hpos
+      @hpos = np
+      @buf = (@hpos == @history.length ? (@stash || +"") : @history[@hpos]).dup
+      @cur = @buf.length; render
+    end
+
+    def word_fwd
+      j = @cur
+      j += 1 while j < @buf.length && @buf[j] !~ /\w/
+      j += 1 while j < @buf.length && @buf[j] =~ /\w/
+      j
+    end
+
+    def word_back
+      j = @cur
+      j -= 1 while j > 0 && @buf[j - 1] !~ /\w/
+      j -= 1 while j > 0 && @buf[j - 1] =~ /\w/
+      j
+    end
+
+    def case_word(method)
+      j = word_fwd
+      return if j == @cur
+      @buf[@cur...j] = @buf[@cur...j].public_send(method)
+      @cur = j
+    end
+
+    def transpose
+      return if @buf.length < 2 || @cur == 0
+      p = @cur >= @buf.length ? @cur - 1 : @cur
+      @buf[p - 1], @buf[p] = @buf[p], @buf[p - 1]
+      @cur = [p + 1, @buf.length].min
+    end
+  end
+end

data/lib/paths.rb

@@ -0,0 +1,44 @@
+module AI
+  # ── Path helpers ─────────────────────────────────────────────────────
+  module Paths
+    module_function
+
+    def short(abs)
+      abs    = File.expand_path(abs)
+      home   = Dir.home
+      tilde  = (abs == home || abs.start_with?(home + "/")) ? "~" + abs[home.length..] : nil
+      relcwd = begin
+                 r = Pathname.new(abs).relative_path_from(Pathname.pwd).to_s
+                 r == "." ? "./" : (r.start_with?("..") ? r : "./" + r)
+               rescue StandardError
+                 nil
+               end
+      [abs, tilde, relcwd].compact.min_by(&:length)
+    end
+
+    def complete(arg)
+      if arg.empty?
+        dir_text = ""; dir_real = "."; base = ""
+      elsif arg.end_with?("/")
+        dir_text = arg
+        dir_real = arg.start_with?("~") ? File.expand_path(arg) : arg
+        base     = ""
+      else
+        slash = arg.rindex("/")
+        if slash
+          dir_text = arg[0..slash]
+          dir_real = dir_text.start_with?("~") ? File.expand_path(dir_text) : dir_text
+          base     = arg[(slash + 1)..]
+        else
+          dir_text = ""; dir_real = "."; base = arg
+        end
+      end
+      return [] unless File.directory?(dir_real)
+      Dir.children(dir_real).select { |e| e.start_with?(base) }.sort.map do |e|
+        full   = File.join(dir_real, e)
+        suffix = File.directory?(full) ? "/" : ""
+        dir_text + e + suffix
+      end
+    end
+  end
+end

data/lib/profile.rb

@@ -0,0 +1,23 @@
+module AI
+  # ── Profile ──────────────────────────────────────────────────────────
+  # Loads user-facing configuration from environment variables.
+  module Profile
+    module_function
+    DEFAULT_SYSTEM = "You are a helpful assistant. Be direct and concise."
+
+    def color(var, fallback)
+      v = ENV[var]
+      v && v.match?(/\A\d+\z/) && (0..255).cover?(v.to_i) ? v.to_i : fallback
+    end
+
+    def load
+      let(
+        name:   ENV["AI_NAME"]   || "Assistant",
+        icon:   ENV["AI_ICON"]   || "\u2726",
+        prompt: ENV["AI_PROMPT"] || "\u276f",
+        color:  color("AI_COLOR", 110),
+        system: ENV["AI_SYSTEM_PROMPT"] || DEFAULT_SYSTEM
+      )
+    end
+  end
+end

data/lib/session.rb

@@ -0,0 +1,111 @@
+module AI
+  # ── Session ──────────────────────────────────────────────────────────
+  class Session
+    attr_accessor :stamp, :title, :messages, :usages
+
+    def initialize
+      @stamp    = Time.now.strftime("%Y%m%d-%H%M%S-%L")
+      @title    = nil
+      @messages = []
+      @usages   = []
+      @mutex    = Mutex.new
+    end
+
+    def turns  = @messages.length / 2
+    def empty? = @messages.empty?
+
+    def add_turn(user_content, assistant_content, usage = nil, attachments: [])
+      user_msg = { "role" => "user", "content" => user_content }
+      user_msg["attachments"] = attachments unless attachments.empty?
+      @messages << user_msg
+      @messages << { "role" => "assistant", "content" => assistant_content }
+      @usages   << usage if usage
+    end
+
+    def remove_turns(first, last)
+      total = turns
+      return 0 if total.zero? || first > total || last < 1
+      first = first.clamp(1, total)
+      last  = last.clamp(1, total)
+      return 0 if first > last
+      count = last - first + 1
+      @messages.slice!((first - 1) * 2, count * 2)
+      if @usages.length >= first
+        take = [count, @usages.length - first + 1].min
+        @usages.slice!(first - 1, take)
+      end
+      @title = nil if @messages.empty?
+      count
+    end
+
+    def discard_last_turn = remove_turns(turns, turns)
+
+    def human_time
+      Time.strptime(@stamp, "%Y%m%d-%H%M%S-%L").strftime("%b %-d, %Y · %-I:%M %p")
+    rescue StandardError
+      @stamp
+    end
+
+    def history_file = File.join(META_DIR, "#{@stamp}.readline")
+    def json_file    = File.join(META_DIR, "#{@stamp}.json")
+    def md_file      = File.join(DATA_DIR, "#{@stamp}.md")
+    def files        = [json_file, md_file, history_file]
+
+    def save(profile)
+      @mutex.synchronize do
+        FileUtils.mkdir_p(META_DIR)
+        File.write(json_file, JSON.pretty_generate(
+          "timestamp" => @stamp,
+          "title"     => @title,
+          "messages"  => @messages,
+          "usages"    => @usages
+        ))
+        write_markdown(profile)
+      end
+    end
+
+    def delete_files
+      files.each { |f| File.delete(f) if File.exist?(f) }
+    end
+
+    def self.all
+      Dir[File.join(META_DIR, "*.json")]
+        .reject { |f| File.basename(f) == "stats.json" }
+        .map    { |f| File.basename(f, ".json") }
+        .sort
+    end
+
+    def self.load(stamp)
+      data = JSON.parse(File.read(File.join(META_DIR, "#{stamp}.json"))) rescue (return nil)
+      return nil unless data.is_a?(Hash)
+      s = new; s.stamp = stamp; s.title = data["title"]
+      if data["messages"].is_a?(Array)
+        s.messages = data["messages"]
+        s.usages   = data["usages"] || data["usage_log"] || []
+      elsif data["branches"].is_a?(Array)
+        first = data["branches"].first || {}
+        s.messages = first["messages"] || []
+        s.usages   = first["usages"]   || []
+      else
+        return nil
+      end
+      s
+    end
+
+    private
+
+    def write_markdown(profile)
+      md = +"# #{@title || @stamp}\n\n**#{profile.icon} #{profile.name}**\n\n"
+      @messages.each do |m|
+        if m["role"] == "user"
+          md << "### You\n\n"
+          (m["attachments"] || []).each { |a| md << "📎 `#{a["path"]}`\n" }
+          md << "\n#{m["content"]}\n\n"
+        else
+          md << "### #{profile.icon} #{profile.name}\n\n#{m["content"]}\n\n"
+        end
+      end
+      File.write(md_file, md)
+    end
+  end
+end

data/lib/stats.rb

@@ -0,0 +1,32 @@
+module AI
+  # ── Stats / cost tracking ────────────────────────────────────────────
+  module Stats
+    module_function
+
+    def blank
+      { "interactions" => 0, "tokens_in" => 0, "tokens_out" => 0, "cost" => 0.0 }
+    end
+
+    def read
+      File.exist?(STATS_FILE) ? (JSON.parse(File.read(STATS_FILE)) rescue blank) : blank
+    end
+
+    def cost(usage)
+      (usage["prompt_cache_hit_tokens"]  || 0) * RATES[:hit]  +
+      (usage["prompt_cache_miss_tokens"] || 0) * RATES[:miss] +
+      (usage["completion_tokens"]        || 0) * RATES[:out]
+    end
+
+    def record(usage)
+      s = read
+      s["interactions"] = s["interactions"].to_i + 1
+      if usage
+        s["tokens_in"]  = s["tokens_in"].to_i  + (usage["prompt_tokens"]     || 0)
+        s["tokens_out"] = s["tokens_out"].to_i + (usage["completion_tokens"] || 0)
+        s["cost"]       = s["cost"].to_f       + cost(usage)
+      end
+      FileUtils.mkdir_p(META_DIR)
+      File.write(STATS_FILE, JSON.pretty_generate(s))
+    end
+  end
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification
+name: aids
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- emanrdesu
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: emanlib
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: Interactive AI assistant with session management, file attachments, syntax
+  highlighting, and cost tracking.
+email:
+- janitor@waifu.club
+executables:
+- aids
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/aids
+- lib/aids.rb
+- lib/ansi.rb
+- lib/app.rb
+- lib/commands.rb
+- lib/highlighter.rb
+- lib/line_editor.rb
+- lib/paths.rb
+- lib/profile.rb
+- lib/session.rb
+- lib/stats.rb
+homepage: https://github.com/emanrdesu/aids
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: AI DeepSeek client REPL for the terminal
+test_files: []