ace-compressor 0.24.1

data/lib/ace/compressor/organisms/agent_compressor.rb

@@ -0,0 +1,325 @@
+# frozen_string_literal: true
+
+require "json"
+require "open3"
+
+module Ace
+  module Compressor
+    module Organisms
+      # Agent mode keeps exact ContextPack structure and asks the LLM to rewrite
+      # only compressible payloads. The model never emits headers, file markers,
+      # or section markers.
+      class AgentCompressor
+        PAYLOAD_PREFIXES = ["SUMMARY|", "FACT|"].freeze
+        PROTECTED_PREFIXES = [
+          "RULE|", "CONSTRAINT|", "CMD|", "TABLE|", "U|", "CODE|", "PROBLEMS|",
+          "EXAMPLE|", "EXAMPLE_REF|", "FILES|", "TREE|", "LOSS|"
+        ].freeze
+        LIST_REWRITE_MIN_ITEMS = 5
+        LIST_REWRITE_MIN_BYTES = 140
+        LIST_STOPWORDS = %w[
+          a an and as at by for from in into is of on or that the this to via with within
+        ].freeze
+        LIST_TOKEN_MAP = {
+          "architecture" => "arch",
+          "architectural" => "arch",
+          "configuration" => "config",
+          "documentation" => "docs",
+          "generation" => "gen",
+          "management" => "mgmt",
+          "repository" => "repo",
+          "repositories" => "repos",
+          "development" => "dev",
+          "integration" => "integr",
+          "execution" => "exec",
+          "reporting" => "reports",
+          "organization" => "org",
+          "organizations" => "orgs",
+          "capabilities" => "caps",
+          "capability" => "cap",
+          "foundation" => "base",
+          "tracking" => "track",
+          "powered" => "pwr",
+          "detected" => "detect",
+          "matching" => "match"
+        }.freeze
+
+        attr_reader :ignored_paths
+
+        def initialize(paths, verbose: false, shell_runner: nil)
+          @exact = ExactCompressor.new(paths, verbose: verbose, mode_label: "agent")
+          @shell_runner = shell_runner || method(:default_shell_runner)
+        end
+
+        def call
+          compress_sources(resolve_sources)
+        end
+
+        def resolve_sources
+          @exact.resolve_sources
+        end
+
+        def ignored_paths
+          @exact.ignored_paths
+        end
+
+        def compress_sources(sources, source_paths: nil)
+          exact_output = @exact.compress_sources(sources, source_paths: source_paths)
+          exact_lines = normalize_output_lines(exact_output)
+          return exact_output if exact_lines.empty?
+
+          job = build_rewrite_job(exact_lines)
+          rewrites = rewrite_payloads(job[:records])
+          rebuild_output(job[:entries], rewrites)
+        end
+
+        private
+
+        def build_rewrite_job(exact_lines)
+          entries = [Ace::Compressor::Models::ContextPack.header("agent")]
+          records = []
+          current_file = nil
+          current_section = nil
+          next_id = 1
+
+          Array(exact_lines).drop(1).each do |line|
+            if line.start_with?("FILE|")
+              current_file = line.sub("FILE|", "").strip
+              entries << line
+              next
+            end
+
+            if line.start_with?("SEC|")
+              current_section = line.sub("SEC|", "").strip
+              entries << line
+              next
+            end
+
+            record = rewrite_record_for(line, current_file, current_section, next_id)
+            if record
+              records << record
+              entries << {rewrite_id: record[:id], original_line: line}
+              next_id += 1
+            else
+              entries << line
+            end
+          end
+
+          {entries: entries, records: records}
+        end
+
+        def rewrite_record_for(line, current_file, current_section, next_id)
+          return nil if line.start_with?(*PROTECTED_PREFIXES)
+
+          if line.start_with?(*PAYLOAD_PREFIXES)
+            type = line.split("|", 2).first
+            return {
+              id: record_id(next_id),
+              type: type,
+              file: current_file,
+              section: current_section,
+              payload: record_payload(line)
+            }
+          end
+
+          return nil unless line.start_with?("LIST|")
+
+          name, items = parse_list_line(line)
+          return nil unless list_rewrite_eligible?(line, items)
+
+          {
+            id: record_id(next_id),
+            type: "LIST",
+            file: current_file,
+            section: current_section,
+            name: name,
+            items: items
+          }
+        end
+
+        def list_rewrite_eligible?(line, items)
+          return false if items.empty?
+
+          items.length >= LIST_REWRITE_MIN_ITEMS || line.bytesize >= LIST_REWRITE_MIN_BYTES
+        end
+
+        def rewrite_payloads(records)
+          return {} if records.empty?
+
+          prompt = compose_prompt(records)
+          response = invoke_agent(prompt)
+          extract_rewrites(records, response)
+        rescue Ace::Compressor::Error, JSON::ParserError
+          {}
+        end
+
+        def compose_prompt(records)
+          <<~PROMPT
+            #{agent_template}
+
+            <records_json>
+            #{JSON.pretty_generate("records" => prompt_records(records))}
+            </records_json>
+          PROMPT
+        end
+
+        def prompt_records(records)
+          Array(records).map do |record|
+            base = {
+              "id" => record[:id],
+              "type" => record[:type],
+              "file" => record[:file],
+              "section" => record[:section]
+            }
+
+            if record[:type] == "LIST"
+              base.merge("items" => record[:items])
+            else
+              base.merge("payload" => record[:payload])
+            end
+          end
+        end
+
+        def agent_template
+          @agent_template ||= execute_command(["ace-bundle", agent_template_uri]).strip
+        end
+
+        def invoke_agent(prompt)
+          execute_command(["ace-llm", agent_model, prompt]).strip
+        end
+
+        def extract_rewrites(records, response)
+          parsed = parse_agent_response(response)
+          rewrites = {}
+          records_by_id = Array(records).each_with_object({}) { |record, hash| hash[record[:id]] = record }
+
+          Array(parsed.fetch("records", [])).each do |candidate|
+            original = records_by_id[candidate["id"]]
+            next unless original
+
+            rewrite = normalized_rewrite(original, candidate)
+            rewrites[original[:id]] = rewrite if rewrite
+          end
+
+          rewrites
+        end
+
+        def parse_agent_response(response)
+          payload = response.to_s.strip
+          payload = payload.sub(/\A```(?:json)?\s*/i, "")
+          payload = payload.sub(/\s*```\z/, "")
+          JSON.parse(payload)
+        end
+
+        def normalized_rewrite(original, candidate)
+          case original[:type]
+          when "SUMMARY", "FACT"
+            payload = normalize_payload_text(candidate["payload"])
+            return nil if payload.empty?
+
+            {type: original[:type], payload: payload}
+          when "LIST"
+            items = Array(candidate["items"]).map { |item| normalize_list_item(item) }
+            return nil unless items.length == original[:items].length
+            return nil if items.any?(&:empty?)
+
+            {type: "LIST", name: original[:name], items: items}
+          end
+        end
+
+        def rebuild_output(entries, rewrites)
+          Array(entries).map do |entry|
+            next entry if entry.is_a?(String)
+
+            rewrite = rewrites[entry[:rewrite_id]]
+            rewrite ? render_rewrite(rewrite) : entry[:original_line]
+          end.join("\n")
+        end
+
+        def render_rewrite(rewrite)
+          case rewrite[:type]
+          when "SUMMARY", "FACT"
+            "#{rewrite[:type]}|#{rewrite[:payload]}"
+          when "LIST"
+            "LIST|#{rewrite[:name]}|[#{rewrite[:items].join(",")}]"
+          else
+            raise Ace::Compressor::Error, "Unsupported agent rewrite type: #{rewrite[:type]}"
+          end
+        end
+
+        def parse_list_line(line)
+          _prefix, name, raw_items = line.split("|", 3)
+          items = raw_items.to_s.sub(/\A\[/, "").sub(/\]\z/, "").split(",").map(&:strip).reject(&:empty?)
+          [name.to_s, items]
+        end
+
+        def record_id(index)
+          "r#{index}"
+        end
+
+        def normalize_output_lines(output)
+          output.to_s.lines.map(&:strip).reject(&:empty?)
+        end
+
+        def normalize_payload_text(text)
+          text.to_s.gsub(/\s+/, " ").strip
+        end
+
+        def normalize_list_item(text)
+          tokens = text.to_s.downcase.gsub(/[^a-z0-9]+/, "_").split("_").reject(&:empty?)
+          tokens = compact_list_tokens(tokens)
+          tokens.join("_")
+        end
+
+        def compact_list_tokens(tokens)
+          compacted = Array(tokens).filter_map do |token|
+            next if LIST_STOPWORDS.include?(token)
+
+            LIST_TOKEN_MAP.fetch(token, token)
+          end
+
+          compacted = compacted.each_with_object([]) do |token, result|
+            result << token unless result.last == token
+          end
+
+          compacted.empty? ? Array(tokens).first(1) : compacted
+        end
+
+        def record_payload(line)
+          line.to_s.split("|", 2).last.to_s
+        end
+
+        def agent_model
+          @agent_model ||= begin
+            config = Ace::Compressor.config
+            model = config["agent_model"].to_s.strip
+            model = config["agent_provider"].to_s.strip if model.empty?
+            raise Ace::Compressor::Error, "Agent model not configured: set compressor.agent_model" if model.empty?
+            model
+          end
+        end
+
+        def agent_template_uri
+          @agent_template_uri ||= begin
+            template_uri = Ace::Compressor.config["agent_template_uri"].to_s.strip
+            raise Ace::Compressor::Error, "Agent template URI not configured: set compressor.agent_template_uri" if template_uri.empty?
+            template_uri
+          end
+        end
+
+        def execute_command(command)
+          stdout, stderr, status = @shell_runner.call(command)
+          return stdout if status.success?
+
+          details = stderr.to_s.strip
+          details = stdout.to_s.strip if details.empty?
+          raise Ace::Compressor::Error, "#{command.first} failed: #{details}"
+        end
+
+        def default_shell_runner(command)
+          Open3.capture3(*command)
+        end
+      end
+    end
+  end
+end

data/lib/ace/compressor/organisms/benchmark_runner.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+require "json"
+require "pathname"
+
+module Ace
+  module Compressor
+    module Organisms
+      class BenchmarkRunner
+        SUPPORTED_FORMATS = %w[table json].freeze
+        SUPPORTED_MODES = CompressionRunner::SUPPORTED_MODES
+
+        def initialize(paths, modes: nil, format: "table", verbose: false)
+          @paths = Array(paths)
+          @modes = parse_modes(modes)
+          @format = (format || "table").to_s
+          @verbose = verbose
+          @resolver = ExactCompressor.new(paths, verbose: verbose)
+          @retention = Ace::Compressor::Atoms::RetentionReporter.new
+        end
+
+        def call
+          raise Ace::Compressor::Error, "Unsupported format '#{@format}'. Use --format table or json" unless SUPPORTED_FORMATS.include?(@format)
+
+          sources = @resolver.resolve_sources
+          per_source = sources.map { |source| benchmark_source(source) }
+          {
+            "sources" => per_source,
+            "summary" => summarize(per_source)
+          }
+        end
+
+        def render(report)
+          return JSON.pretty_generate(report) if @format == "json"
+
+          render_table(report.fetch("sources"))
+        end
+
+        private
+
+        def parse_modes(modes)
+          values = Array(modes || SUPPORTED_MODES)
+          values = values.flat_map { |value| value.to_s.split(",") }.map(&:strip).reject(&:empty?)
+          values = SUPPORTED_MODES if values.empty?
+          unknown = values - SUPPORTED_MODES
+          raise Ace::Compressor::Error, "Unsupported modes: #{unknown.join(", ")}" unless unknown.empty?
+
+          values.uniq
+        end
+
+        def benchmark_source(source)
+          exact_result = run_mode(source, "exact")
+          reference_content = exact_result["content"]
+
+          {
+            "source" => relative_source(source),
+            "modes" => @modes.map { |mode| mode_report(source, mode, reference_content, exact_result) }
+          }
+        end
+
+        def mode_report(source, mode, reference_content, exact_result)
+          result = (mode == "exact") ? exact_result : run_mode(source, mode)
+          return result.merge("mode" => mode) unless result["status"] == "ok"
+
+          metrics = @retention.compare(reference_content: reference_content, candidate_content: result.fetch("content"))
+          metadata = result.fetch("metadata")
+
+          {
+            "mode" => mode,
+            "status" => "ok",
+            "cache" => result.fetch("cache_hit") ? "hit" : "miss",
+            "output_path" => result.fetch("output_path"),
+            "original_bytes" => metadata.fetch("original_bytes"),
+            "original_lines" => metadata.fetch("original_lines"),
+            "packed_bytes" => metadata.fetch("packed_bytes"),
+            "packed_lines" => metadata.fetch("packed_lines"),
+            "byte_change_percent" => percent_change(metadata.fetch("original_bytes"), metadata.fetch("packed_bytes")),
+            "line_change_percent" => percent_change(metadata.fetch("original_lines"), metadata.fetch("packed_lines")),
+            "coverage" => metrics
+          }
+        end
+
+        def run_mode(source, mode)
+          result = CompressionRunner.new([source], mode: mode, format: "path", verbose: @verbose).call
+          {
+            "status" => result[:exit_code].to_i.zero? ? "ok" : "nonzero",
+            "cache_hit" => result[:cache_hit],
+            "metadata" => result[:metadata],
+            "output_path" => result[:output_path],
+            "content" => File.read(result[:output_path]),
+            "refusal_lines" => result[:refusal_lines],
+            "fallback_lines" => result[:fallback_lines]
+          }
+        rescue => e
+          {
+            "status" => "error",
+            "error" => e.message
+          }
+        end
+
+        def render_table(per_source)
+          rows = [["Source", "Mode", "Cache", "Bytes", "Lines", "Secs", "Prot", "Struct", "Loss", "Status"]]
+
+          per_source.each do |entry|
+            entry.fetch("modes").each do |mode|
+              if mode.fetch("status") != "ok"
+                rows << [entry.fetch("source"), mode.fetch("mode"), "-", "-", "-", "-", "-", "-", "-", mode.fetch("status")]
+                next
+              end
+
+              coverage = mode.fetch("coverage")
+              rows << [
+                entry.fetch("source"),
+                mode.fetch("mode"),
+                mode.fetch("cache"),
+                format_change(mode.fetch("byte_change_percent")),
+                format_change(mode.fetch("line_change_percent")),
+                coverage_ratio(coverage.fetch("sections")),
+                coverage_ratio(coverage.fetch("protected")),
+                coverage_ratio(coverage.fetch("structured")),
+                total_loss_markers(coverage.fetch("loss_markers")),
+                mode.fetch("status")
+              ]
+            end
+          end
+
+          render_rows(rows)
+        end
+
+        def render_rows(rows)
+          widths = rows.transpose.map { |column| column.map { |cell| cell.to_s.length }.max }
+          rows.map.with_index do |row, index|
+            line = row.each_with_index.map { |cell, column| cell.to_s.ljust(widths[column]) }.join("  ")
+            (index == 0) ? "#{line}\n#{widths.map { |width| "-" * width }.join("  ")}" : line
+          end.join("\n")
+        end
+
+        def coverage_ratio(metric)
+          "#{metric.fetch("retained")}/#{metric.fetch("total")} (#{metric.fetch("percent")}%)"
+        end
+
+        def total_loss_markers(markers)
+          markers.values.sum
+        end
+
+        def percent_change(original, packed)
+          return 0.0 if original.to_f.zero?
+
+          (((packed.to_f - original.to_f) / original.to_f) * 100.0).round(1)
+        end
+
+        def format_change(value)
+          format("%+.1f%%", value)
+        end
+
+        def summarize(per_source)
+          rows = per_source.flat_map { |entry| entry.fetch("modes") }.select { |row| row.fetch("status") == "ok" }
+          {
+            "sources" => per_source.size,
+            "rows" => rows.size
+          }
+        end
+
+        def relative_source(source)
+          Pathname.new(File.expand_path(source)).relative_path_from(Pathname.new(Dir.pwd)).to_s
+        rescue ArgumentError
+          source
+        end
+      end
+    end
+  end
+end