harnex 0.4.0 → 0.6.0

data/lib/harnex/commands/run.rb

@@ -7,11 +7,12 @@ module Harnex
     DEFAULT_TIMEOUT = 5.0
     KNOWN_FLAGS = %w[
       --id --description --detach --tmux --host --port --watch --watch-file
-      --stall-after --max-resumes --preset --context --timeout --inbox-ttl --help
+      --stall-after --max-resumes --preset --context --meta --summary-out
+      --timeout --inbox-ttl --legacy-pty --help
     ].freeze
     VALUE_FLAGS = %w[
       --id --description --host --port --watch --watch-file --stall-after
-      --max-resumes --preset --context --timeout --inbox-ttl
+      --max-resumes --preset --context --meta --summary-out --timeout --inbox-ttl
     ].freeze
 
     def self.usage(program_name = "harnex run")
@@ -31,8 +32,13 @@ module Harnex
           --preset NAME      Watch preset: impl, plan, gate (requires --watch)
           --watch-file PATH  Auto-send a file-change hook on modification
           --context TEXT     Inject as the initial prompt (prepends session header)
+          --meta JSON        Attach parsed JSON metadata to the started event
+          --summary-out PATH Append dispatch telemetry summary JSONL to PATH
           --timeout SECS     Max seconds to wait for detached registration (default: #{DEFAULT_TIMEOUT})
           --inbox-ttl SECS   Expire queued inbox messages after SECS (default: #{Inbox::DEFAULT_TTL})
+          --legacy-pty       (codex only) Use the legacy PTY adapter instead of
+                             the JSON-RPC `app-server` adapter. Deprecated; will
+                             be removed in 0.7.0.
           -h, --help         Show this help
 
         Notes:
@@ -60,11 +66,14 @@ module Harnex
         preset: nil,
         watch: nil,
         context: nil,
+        meta: nil,
+        summary_out: nil,
         detach: false,
         tmux: false,
         tmux_name: nil,
         timeout: DEFAULT_TIMEOUT,
         inbox_ttl: default_inbox_ttl,
+        legacy_pty: false,
         help: false
       }
     end
@@ -79,10 +88,11 @@ module Harnex
       raise OptionParser::MissingArgument, "cli" if cli_name.nil?
 
       repo_root = Harnex.resolve_repo_root(adapter_repo_path(cli_name, child_args))
+      @options[:summary_out] = resolve_summary_out(repo_root)
       @options[:id] ||= Harnex.generate_id(repo_root)
       validate_unique_id!(repo_root)
       effective_child_args = apply_context(child_args)
-      adapter = Harnex.build_adapter(cli_name, effective_child_args)
+      adapter = Harnex.build_adapter(cli_name, effective_child_args, legacy_pty: @options[:legacy_pty])
       @options[:detach] = true if @options[:tmux]
       validate_watch_mode!
       resolve_watch_preset!
@@ -137,7 +147,10 @@ module Harnex
       tmux_cmd += ["--port", @options[:port].to_s] if @options[:port]
       tmux_cmd += ["--watch-file", @options[:watch]] if @options[:watch]
       tmux_cmd += ["--context", @options[:context]] if @options[:context]
+      tmux_cmd += ["--meta", JSON.generate(@options[:meta])] if @options[:meta]
+      tmux_cmd += ["--summary-out", @options[:summary_out]] if @options[:summary_out]
       tmux_cmd += ["--inbox-ttl", @options[:inbox_ttl].to_s]
+      tmux_cmd += ["--legacy-pty"] if @options[:legacy_pty]
       tmux_cmd += ["--"] + child_args unless child_args.empty?
 
       window_name = @options[:tmux_name] || @options[:id]
@@ -239,12 +252,14 @@ module Harnex
         id: @options[:id],
         watch: watch,
         description: @options[:description],
+        meta: @options[:meta],
+        summary_out: @options[:summary_out],
         inbox_ttl: @options[:inbox_ttl]
       )
     end
 
     def adapter_repo_path(cli_name, child_args)
-      Harnex.build_adapter(cli_name, child_args).infer_repo_path(child_args)
+      Harnex.build_adapter(cli_name, child_args, legacy_pty: @options[:legacy_pty]).infer_repo_path(child_args)
     end
 
     def apply_context(child_args)
@@ -385,6 +400,16 @@ module Harnex
           @options[:context] = required_option_value(arg, argv[index])
         when /\A--context=(.+)\z/
           @options[:context] = required_option_value("--context", Regexp.last_match(1))
+        when "--meta"
+          index += 1
+          @options[:meta] = parse_meta(required_option_value(arg, argv[index]))
+        when /\A--meta=(.+)\z/
+          @options[:meta] = parse_meta(required_option_value("--meta", Regexp.last_match(1)))
+        when "--summary-out"
+          index += 1
+          @options[:summary_out] = required_option_value(arg, argv[index])
+        when /\A--summary-out=(.+)\z/
+          @options[:summary_out] = required_option_value("--summary-out", Regexp.last_match(1))
         when "--timeout"
           index += 1
           @options[:timeout] = Float(required_option_value(arg, argv[index]))
@@ -395,6 +420,8 @@ module Harnex
           @options[:inbox_ttl] = Float(required_option_value(arg, argv[index]))
         when /\A--inbox-ttl=(.+)\z/
           @options[:inbox_ttl] = Float(required_option_value("--inbox-ttl", Regexp.last_match(1)))
+        when "--legacy-pty"
+          @options[:legacy_pty] = true
         else
           if cli_name.nil?
             cli_name = arg
@@ -434,13 +461,13 @@ module Harnex
         case arg
         when "--"
           return false
-        when "-h", "--help", "--detach", "--tmux"
+        when "-h", "--help", "--detach", "--tmux", "--legacy-pty"
           nil
         when /\A--tmux=/
           nil
         when *VALUE_FLAGS
           index += 1
-        when /\A--(?:id|description|host|port|watch|watch-file|stall-after|max-resumes|context|timeout|inbox-ttl)=/
+        when /\A--(?:id|description|host|port|watch|watch-file|stall-after|max-resumes|context|meta|summary-out|timeout|inbox-ttl)=/
           nil
         when /\A--preset=/
           nil
@@ -458,7 +485,8 @@ module Harnex
         arg == "-h" ||
         arg.start_with?(
           "--id=", "--description=", "--tmux=", "--host=", "--port=", "--watch=", "--watch-file=",
-          "--stall-after=", "--max-resumes=", "--preset=", "--context=", "--timeout=", "--inbox-ttl="
+          "--stall-after=", "--max-resumes=", "--preset=", "--context=", "--meta=", "--summary-out=",
+          "--timeout=", "--inbox-ttl="
         )
     end
 
@@ -489,6 +517,22 @@ module Harnex
       raise OptionParser::InvalidArgument, "#{option_name} must be an integer"
     end
 
+    def parse_meta(value)
+      parsed = JSON.parse(value)
+      return parsed if parsed.is_a?(Hash)
+
+      raise OptionParser::InvalidOption, "--meta must be a JSON object"
+    rescue JSON::ParserError => e
+      raise OptionParser::InvalidOption, "--meta must be valid JSON: #{e.message}"
+    end
+
+    def resolve_summary_out(repo_root)
+      configured = @options[:summary_out]
+      return Harnex.default_summary_out_path(repo_root) if configured.nil?
+
+      File.expand_path(configured, repo_root)
+    end
+
     def default_inbox_ttl
       value = ENV["HARNEX_INBOX_TTL"]
       return Inbox::DEFAULT_TTL.to_f if value.nil? || value.strip.empty?

data/lib/harnex/commands/wait.rb

@@ -7,14 +7,20 @@ module Harnex
   class Waiter
     POLL_INTERVAL = 0.5
 
+    EVENT_PREDICATES = %w[task_complete].freeze
+
     def self.usage(program_name = "harnex wait")
       <<~TEXT
         Usage: #{program_name} [options]
 
         Options:
           --id ID         Session ID to wait for (required)
-          --until STATE   Wait until session reaches STATE (e.g. "prompt")
-                          Without --until, waits for session exit (default)
+          --until STATE   Wait until session reaches STATE. Supported:
+                            task_complete   (events JSONL — fires on
+                                             turn/completed; adapter-agnostic)
+                            <other>         (agent_state HTTP poll, e.g.
+                                             "prompt", "busy")
+                          Without --until, waits for session exit (default).
           --repo PATH     Resolve session using PATH's repo root (default: current repo)
           --timeout SECS  Maximum time to wait in seconds (default: unlimited)
           -h, --help      Show this help
@@ -42,7 +48,11 @@ module Harnex
       raise "--id is required for harnex wait" unless @options[:id]
 
       if @options[:until_state]
-        wait_until_state
+        if EVENT_PREDICATES.include?(@options[:until_state])
+          wait_until_event(@options[:until_state])
+        else
+          wait_until_state
+        end
       else
         wait_until_exit
       end
@@ -50,6 +60,102 @@ module Harnex
 
     private
 
+    def wait_until_event(predicate)
+      repo_root = Harnex.resolve_repo_root(@options[:repo_path])
+      events_path = Harnex.events_log_path(repo_root, @options[:id])
+      registry = Harnex.read_registry(repo_root, @options[:id])
+      start_time = Time.now
+      deadline = @options[:timeout] ? start_time + @options[:timeout] : nil
+
+      unless registry || File.exist?(events_path)
+        warn("harnex wait: no session found with id #{@options[:id].inspect}")
+        return 1
+      end
+
+      offset = 0
+      task_complete_seen = false
+
+      # Replay existing events first — we may already be past the predicate.
+      if File.exist?(events_path)
+        File.open(events_path, "r") do |f|
+          f.each_line do |line|
+            offset = f.pos
+            event = parse_event(line)
+            next unless event
+            task_complete_seen = true if event["type"] == "task_complete"
+            if matches?(event, predicate, task_complete_seen)
+              return emit_event_match(event, start_time)
+            end
+          end
+        end
+      end
+
+      target_pid = registry && registry["pid"]
+
+      loop do
+        if target_pid && !Harnex.alive_pid?(target_pid)
+          waited = (Time.now - start_time).round(1)
+          puts JSON.generate(ok: false, id: @options[:id], state: "exited", waited_seconds: waited)
+          return 1
+        end
+
+        if deadline && Time.now >= deadline
+          waited = (Time.now - start_time).round(1)
+          puts JSON.generate(ok: false, id: @options[:id], status: "timeout", waited_seconds: waited)
+          return 124
+        end
+
+        if File.exist?(events_path) && File.size(events_path) > offset
+          File.open(events_path, "r") do |f|
+            f.seek(offset)
+            f.each_line do |line|
+              event = parse_event(line)
+              next unless event
+              task_complete_seen = true if event["type"] == "task_complete"
+              if matches?(event, predicate, task_complete_seen)
+                offset = f.pos
+                return emit_event_match(event, start_time)
+              end
+            end
+            offset = f.pos
+          end
+        end
+
+        sleep 0.1
+      end
+    end
+
+    def parse_event(line)
+      JSON.parse(line)
+    rescue JSON::ParserError
+      nil
+    end
+
+    def matches?(event, predicate, task_complete_seen)
+      type = event["type"]
+      case predicate
+      when "task_complete"
+        type == "task_complete"
+      when "prompt"
+        type == "task_complete" ||
+          (task_complete_seen && type == "agent_state" && event["state"] == "prompt")
+      else
+        false
+      end
+    end
+
+    def emit_event_match(event, start_time)
+      waited = (Time.now - start_time).round(1)
+      puts JSON.generate(
+        ok: true,
+        id: @options[:id],
+        event: event["type"],
+        seq: event["seq"],
+        waited_seconds: waited
+      )
+      0
+    end
+
     def wait_until_state
       repo_root = Harnex.resolve_repo_root(@options[:repo_path])
       target_state = @options[:until_state]

data/lib/harnex/core.rb

@@ -64,6 +64,67 @@ module Harnex
     seconds
   end
 
+  def harness_version
+    VERSION
+  end
+
+  def host_info
+    {
+      host: Socket.gethostname,
+      platform: RUBY_PLATFORM
+    }
+  rescue StandardError
+    {
+      host: nil,
+      platform: RUBY_PLATFORM
+    }
+  end
+
+  def strip_ansi(text)
+    text.to_s.gsub(/\e\[[0-9;]*[a-zA-Z]/, "")
+  end
+
+  def default_summary_out_path(repo_root)
+    koder_dir = File.join(repo_root.to_s, "koder")
+    return nil unless File.directory?(koder_dir)
+
+    File.join(koder_dir, "DISPATCH.jsonl")
+  end
+
+  def git_capture_start(repo_root)
+    sha = git_output(repo_root, "rev-parse", "HEAD")
+    branch = git_output(repo_root, "rev-parse", "--abbrev-ref", "HEAD")
+    return {} if sha.empty? || branch.empty?
+
+    {
+      sha: sha,
+      branch: branch
+    }
+  rescue StandardError
+    {}
+  end
+
+  def git_capture_end(repo_root, start_sha)
+    start_sha = start_sha.to_s.strip
+    return {} if start_sha.empty?
+
+    end_sha = git_output(repo_root, "rev-parse", "HEAD")
+    range = "#{start_sha}..#{end_sha}"
+    shortstat = git_output(repo_root, "diff", "--shortstat", range)
+    commits = Integer(git_output(repo_root, "rev-list", "--count", range))
+    stats = parse_git_shortstat(shortstat)
+
+    {
+      sha: end_sha,
+      loc_added: stats.fetch(:loc_added),
+      loc_removed: stats.fetch(:loc_removed),
+      files_changed: stats.fetch(:files_changed),
+      commits: commits
+    }
+  rescue StandardError
+    {}
+  end
+
   def repo_key(repo_root)
     Digest::SHA256.hexdigest(repo_root)[0, 16]
   end
@@ -288,10 +349,10 @@ module Harnex
     false
   end
 
-  def build_adapter(cli, argv)
+  def build_adapter(cli, argv, legacy_pty: false)
     raise ArgumentError, "cli is required" if cli.to_s.strip.empty?
 
-    Adapters.build(cli, argv)
+    Adapters.build(cli, argv, legacy_pty: legacy_pty)
   end
 
   def session_cli(session)
@@ -316,4 +377,19 @@ module Harnex
       debounce_seconds: WATCH_DEBOUNCE_SECONDS
     )
   end
+
+  def git_output(repo_root, *args)
+    stdout, _stderr, status = Open3.capture3("git", "-C", repo_root.to_s, *args)
+    raise "git #{args.join(' ')} failed" unless status.success?
+
+    stdout.strip
+  end
+
+  def parse_git_shortstat(text)
+    {
+      files_changed: text.to_s[/(\d+)\s+files?\s+changed/, 1].to_i,
+      loc_added: text.to_s[/(\d+)\s+insertions?\(\+\)/, 1].to_i,
+      loc_removed: text.to_s[/(\d+)\s+deletions?\(-\)/, 1].to_i
+    }
+  end
 end