samagotchi 0.53.0 → 0.55.0

data/lib/samagotchi/tool_activity.rb

@@ -43,8 +43,10 @@ module Samagotchi
         action: tool_activity_action(tool_name, registry: registry, call: call),
         tool: tool_name,
         params: tool_activity_params(tool_name, call, registry: registry),
-        status: tool_activity_status(result, tool_name)
+        status: tool_activity_status(result, tool_name, command: call.is_a?(Hash) ? call[:content] : nil)
       }
+      # A grep that found nothing: ok, and the web row says "no match".
+      event[:no_match] = true if event[:status] == "ok" && tool_name == Tools::Execute::NAME && execute_failed?(result.to_s)
       title = tool_title(tool_name, call, cwd: cwd)
       event[:title] = title if title
       # The name the model used when an alias ran a built-in (called_as: "bash"
@@ -181,13 +183,6 @@ module Samagotchi
       end
     end
 
-    # "error" for an "Error:" result, and for an execute whose command
-    # exited non-zero (its last "exit: N" line; no number: killed by a
-    # signal), so the turn tally's "(N failed)" counts it. "stopped" for a
-    # task_wait the user's Stop ended (the task itself runs on), for one
-    # whose task was stopped (the stop-task button, or the model's task_stop),
-    # and for a command the user's Stop killed or kept from starting: a
-    # cancel, not a failure (its text still starts "Error:" for the model).
     # memory_write's label: a call with only a description changes the index line.
     def memory_write_action(call)
       return "saving memory" unless call.is_a?(Hash)
@@ -205,23 +200,98 @@ module Samagotchi
       request.ids.empty? && request.restore? ? "restoring outputs" : "forgetting outputs"
     end
 
-    def tool_activity_status(result, tool_name = nil)
+    # "error" for an "Error:" result, and for an execute whose command
+    # exited non-zero (its last "exit: N" line; no number: killed by a
+    # signal), so the turn tally's "(N failed)" counts it; but not a grep
+    # that found nothing (no_match?, given the +command+): that stays "ok".
+    # "stopped" for a
+    # task_wait the user's Stop ended (the task itself runs on), for one
+    # whose task was stopped (the stop-task button, or the model's task_stop),
+    # and for a command the user's Stop killed or kept from starting: a
+    # cancel, not a failure (its text still starts "Error:" for the model).
+    def tool_activity_status(result, tool_name = nil, command: nil)
       text = result.to_s
       return "stopped" if text == Tools::Execute::NOT_RUN_ON_STOP
       return "stopped" if tool_name == Tools::Execute::NAME && text.start_with?(Tools::Execute::STOPPED_BY_USER)
       return "error" if text.start_with?("Error:")
-      return "error" if tool_name == Tools::Execute::NAME && execute_failed?(text)
+      if tool_name == Tools::Execute::NAME && execute_failed?(text)
+        return no_match?(text, command) ? "ok" : "error"
+      end
       return "stopped" if tool_name == Tools::TaskWait::NAME && text.match?(/^(wait_result: canceled|status: stopped)$/)
 
       "ok"
     end
 
     def execute_failed?(text)
-      exit_line = text.lines.reverse_each.find { |line| line.start_with?("exit: ") }
-      return false unless exit_line
+      code = execute_exit_code(text)
+      !code.nil? && code != "0"
+    end
+
+    # The code on an execute result's last "exit: N" line ("" when killed
+    # by a signal); nil with no exit line.
+    def execute_exit_code(text)
+      exit_line = text.to_s.lines.reverse_each.find { |line| line.start_with?("exit: ") }
+      exit_line && exit_line[/\Aexit: (\d*)/, 1]
+    end
+
+    # The grep family: exit 1 means "searched, found nothing".
+    NO_MATCH_COMMANDS = %w[grep egrep fgrep rg ag pgrep].freeze
+    # Commands that can fail without a message, so an "&&" after them may
+    # hide which step exited 1.
+    SILENT_FAILERS = ["test", "[", "[[", "false", "diff", "cmp", "which", "type", "hash"].freeze
+    QUIET_FLAGS = %w[-q --quiet -s].freeze
+    # Any output sent to /dev/null (">", "1>", "2>", ">>"): its message may be gone.
+    TO_DEV_NULL = %r{>\s*/dev/null}
+    # Commands that end the script with their own code: the exit 1 may be theirs.
+    EXITS = %w[exit return].freeze
+
+    # An execute that exited 1 with no stderr block, whose last step is a
+    # grep-family command, and where no "&&" follows a step that could have
+    # failed silently: a search that found nothing, not a failure. Also
+    # false with a background "&" step (CommandSteps splits "&>" there too),
+    # an earlier exit/return, or set -e (any earlier step's failure ends the
+    # script). When unsure (no command, a command CommandSteps can't read),
+    # false.
+    def no_match?(text, command)
+      return false if command.nil? || execute_exit_code(text) != "1"
+      return false if text.to_s.each_line.any? { |line| line.chomp == "stderr:" }
+
+      steps = CommandSteps.parse(command)&.steps
+      return false unless steps && NO_MATCH_COMMANDS.include?(step_words(steps.last).first)
+      return false if steps.any? { |step| step.op == "&" }
+      return false if steps[0...-1].any? { |step| ends_script?(step) }
+
+      steps.each_cons(2).none? { |step, after| after.op == "&&" && silent_failer?(step) }
+    end
+
+    # A step's words from its command word on: no NAME=value prefixes, the
+    # command word without its path.
+    def step_words(step)
+      words = Guardrails::ShellLex.lex(step.text).filter_map { |kind, value| value if kind == :word }
+      words = words.drop_while { |word| word.match?(/\A[A-Za-z_][A-Za-z0-9_]*=/) }
+      return [] if words.empty?
+
+      [File.basename(words.first), *words.drop(1)]
+    end
+
+    # exit / return, or set -e (-e alone or in a flag group, -o errexit).
+    def ends_script?(step)
+      name, *args = step_words(step)
+      return true if EXITS.include?(name)
+      return false unless name == "set"
+
+      args.any? { |arg| arg.match?(/\A-[a-z]*e/) } || args.each_cons(2).include?(%w[-o errexit])
+    end
+
+    def silent_failer?(step)
+      return true if step.text.match?(TO_DEV_NULL) || step.text.lstrip.start_with?("((")
+
+      name, *args = step_words(step)
+      return true if SILENT_FAILERS.include?(name)
+      return true if name == "command" && args.intersect?(%w[-v -V])
+      return true if NO_MATCH_COMMANDS.include?(name) && args.intersect?(QUIET_FLAGS)
 
-      code = exit_line[/\Aexit: (\d*)/, 1]
-      code != "0"
+      name == "git" && args.first == "diff" && args.intersect?(%w[--quiet --exit-code])
     end
 
     def tool_activity_params(tool_name, call, registry: nil)

data/lib/samagotchi/tool_row_fields.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative "tool_activity"
+require_relative "tool_view"
+require_relative "file_ref"
+
+module Samagotchi
+  # The fields a tool row shows beyond its params, built from the call in
+  # one place for every path: the live tool_call_started (ToolRunner#run)
+  # and a reload from the saved call (Web::MessageParts#tool_part). The
+  # bridge's snapshot and replay (Bridge::TurnAccumulator) copy them by
+  # these lists, so a new field is added here and travels everywhere.
+  #
+  # They travel in two places:
+  # * ACTIVITY_KEYS: top-level on tool_call_started, inside +activity+ on
+  #   tool_call_completed (ToolActivity.tool_activity_event builds that
+  #   activity itself, for the TUI and the metrics);
+  # * EVENT_KEYS: top-level on both, so a UI that missed the start (a
+  #   replay gap) builds its row from the completed event.
+  #
+  # params and label stay where they are: their sources differ per path
+  # (the registry's preview, a plugin's label, the saved shown params).
+  module ToolRowFields
+    ACTIVITY_KEYS = %i[title called_as].freeze
+    EVENT_KEYS = %i[view ref].freeze
+    KEYS = (ACTIVITY_KEYS + EVENT_KEYS).freeze
+
+    module_function
+
+    # @param cwd [String, nil] the session's working directory (the title is
+    #   relative to it when inside it)
+    # @return [Hash] title (a few words: a project-relative path, a command
+    #   without its "cd … &&"), called_as (the name the model called it by
+    #   when that was an alias's: bash), view (ToolView: the full command)
+    #   and ref (FileRef: the file a file tool touched), each only when
+    #   there is one
+    def for(tool_name, call, cwd:)
+      {
+        title: ToolActivity.tool_title(tool_name, call, cwd: cwd),
+        called_as: call[:called_as],
+        view: ToolView.for(tool_name, call)&.to_h,
+        ref: FileRef.for(tool_name, call, cwd: cwd)&.to_h
+      }.compact
+    end
+  end
+end

data/lib/samagotchi/tool_runner.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "tool_activity"
-require_relative "tool_view"
+require_relative "tool_row_fields"
 require_relative "guardrails"
 require_relative "vision_context"
 require_relative "log"
@@ -54,14 +54,10 @@ module Samagotchi
       started = { type: :tool_call_started, iteration: iteration, call_count: call_count, call_index: call_index,
                   tool: call[:name], call: call.dup, params: params }
       started[:label] = label if label
-      # The worker runs in its session's working directory.
-      title = ToolActivity.tool_title(call[:name], call, cwd: Dir.pwd)
-      started[:title] = title if title
-      # The name the model called it by when that was an alias's (bash).
-      started[:called_as] = call[:called_as] if call[:called_as]
-      # The full command for a richer UI (params stays cut at 80).
-      view = ToolView.for(call[:name], call)&.to_h
-      started[:view] = view if view
+      # Its row fields (ToolRowFields: title, called_as, view, ref); the worker runs in
+      # its session's working directory.
+      fields = ToolRowFields.for(call[:name], call, cwd: Dir.pwd)
+      started.merge!(fields)
       emit(on_stream_event, started)
 
       # The ask comes after tool_call_started: the UI shows the tool line,
@@ -102,8 +98,8 @@ module Samagotchi
       completed[:diff] = diff if diff
       completed[:waited_ms] = waited_ms if waited_ms
       # Also here: a UI that missed the start (a replay gap) builds its row
-      # from this event.
-      completed[:view] = view if view
+      # from this event (its title is in the activity).
+      completed.merge!(fields.slice(*ToolRowFields::EVENT_KEYS))
       emit(on_stream_event, completed)
       # After the completed event: a hook's card (check-in, skills) prints
       # under the call's tool row, not before it.

data/lib/samagotchi/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Samagotchi
-  VERSION = "0.53.0"
+  VERSION = "0.55.0"
   # Sent as the User-Agent of every HTTP request chi makes.
   USER_AGENT = "chi/#{VERSION}"
 end

data/lib/samagotchi/web/app.rb

@@ -40,6 +40,7 @@ require_relative "../context_providers"
 require_relative "../recap_store"
 require_relative "markdown_renderer"
 require_relative "capabilities"
+require_relative "editor"
 require_relative "message_parts"
 require_relative "session_summary"
 require_relative "../log"
@@ -88,6 +89,9 @@ module Samagotchi
       # @param annotate_presets [String, Array] the quick replies next to
       #   Annotate (web.annotate_presets, "|"-separated); "" shows none. The
       #   page parses them (annotate_presets.js).
+      # @param editor [String] what a ref opens on this machine (web.editor:
+      #   a preset or a URL template, Web::Editor); only a local viewer gets
+      #   it (#viewer_editor)
       # @param hub [SessionHub, nil] the session projection GET /api/sessions
       #   lists and GET /api/events streams from (Server always builds one);
       #   without one both routes answer 503
@@ -102,6 +106,7 @@ module Samagotchi
       def initialize(manager: nil, session_class: nil, state_dir: nil, public_dir: nil,
                      bridge_wait_timeout: BRIDGE_WAIT_TIMEOUT, markdown: false, view: Config::BY_KEY["web.view"].default, hub: nil,
                      annotate_presets: Config::BY_KEY["web.annotate_presets"].default,
+                     editor: Config::BY_KEY["web.editor"].default,
                      events_heartbeat: EVENTS_HEARTBEAT, events_queue: EVENTS_QUEUE,
                      registry: nil, models_wait_timeout: MODELS_WAIT_TIMEOUT, lan: nil)
         @manager = manager || SessionManager
@@ -117,6 +122,7 @@ module Samagotchi
         @markdown_renderer = MarkdownRenderer.new(enabled: markdown)
         @view = view
         @annotate_presets = annotate_presets.is_a?(Array) ? annotate_presets.join("|") : annotate_presets.to_s
+        @editor_url = Editor.template(editor)
         @hub = hub
         @events_heartbeat = events_heartbeat
         @events_queue = events_queue
@@ -212,6 +218,23 @@ module Samagotchi
                                    ms: ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - started) * 1000).round)
       end
 
+      # The payload's capabilities (Capabilities, per request) and, next to
+      # them, editor_url: the URL template a ref opens (web.editor), nil
+      # when this viewer can't open one.
+      def viewer_capabilities(req)
+        editor_url = @editor_url && local_viewer?(req) ? @editor_url : nil
+        { capabilities: Capabilities.for(@markdown_renderer, editor: !editor_url.nil?).to_h, editor_url: editor_url }
+      end
+
+      # A viewer on this machine, whose editor can open the session's
+      # paths: a loopback peer, or this Mac on its own LAN address (the LAN
+      # URL or its QR code opened here). The phone isn't. An SSH tunnel or
+      # a local reverse proxy looks like loopback too (a known gap).
+      def local_viewer?(req)
+        peer = req.get_header("REMOTE_ADDR").to_s
+        LOOPBACK_PEERS.include?(peer) || (!@lan.nil? && peer == @lan[:ip])
+      end
+
       LOOPBACK_NAMES = %w[127.0.0.1 [::1] localhost].freeze
       LOOPBACK_PEERS = %w[127.0.0.1 ::1 ::ffff:127.0.0.1].freeze
 
@@ -698,7 +721,7 @@ module Samagotchi
       # the new link started is not a refusal of it.
       def continue_from(given, prompt:, title:)
         [@manager.continue_session(given, prompt: prompt, title: title, state_dir: @state_dir), nil]
-      rescue SessionManager::ContinueRefused => e
+      rescue SessionContinue::Refused => e
         extra = e.reason == :continued ? { next_id: e.ids.first } : { ids: e.ids }
         [nil, json_response(409, { error: e.reason.to_s, detail: e.message, **extra })]
       rescue SessionManager::ArchiveRefused => e
@@ -821,7 +844,7 @@ module Samagotchi
           # names its plugins' too.
           commands: turn_snapshot&.fetch("commands", nil) || SessionCommands.builtin_registry.listing,
           markdown_warning: @markdown_renderer.warning,
-          capabilities: Capabilities.for(@markdown_renderer).to_h,
+          **viewer_capabilities(req),
           pending_question: pending,
           last_event_seq: last_event_seq,
           # The stream cursor `<seq>-<epoch>`: a later worker resets it
@@ -881,7 +904,7 @@ module Samagotchi
           session: session_json,
           messages: messages,
           markdown_warning: @markdown_renderer.warning,
-          capabilities: Capabilities.for(@markdown_renderer).to_h,
+          **viewer_capabilities(req),
           timing: timing
         })
       rescue ArgumentError => e

data/lib/samagotchi/web/capabilities.rb

@@ -3,16 +3,20 @@
 module Samagotchi
   module Web
     # What this web page renders that a notice may stand in for
-    # (Engine#hook_notify's fallback_for:). The session and tail JSON carry
-    # it as +capabilities+; the page leaves out a notice whose fallback_for
-    # names a capability that is true here. +display+: the answer's display
-    # is rendered as markdown, so its links are links (web.markdown on and
-    # commonmarker installed). A later capability is a new member. (The
-    # member hides Object#display, which nothing calls on it.)
-    Capabilities = Data.define(:display) do # rubocop:disable Lint/DataDefineOverride
+    # (Engine#hook_notify's fallback_for:), and what this viewer can do. The
+    # session and tail JSON carry it as +capabilities+; the page leaves out
+    # a notice whose fallback_for names a capability that is true here.
+    # +display+: the answer's display is rendered as markdown, so its links
+    # are links (web.markdown on and commonmarker installed). +editor+: this
+    # viewer can open a path in this machine's editor (a viewer on this
+    # machine, web.editor not none); per request, the URL template goes next
+    # to it as the payload's editor_url. A later capability is a new member.
+    # (The member hides Object#display, which nothing calls on it.)
+    Capabilities = Data.define(:display, :editor) do # rubocop:disable Lint/DataDefineOverride
       # @param markdown_renderer [MarkdownRenderer]
-      def self.for(markdown_renderer)
-        new(display: markdown_renderer.available? == true)
+      # @param editor [Boolean] this request's viewer can open refs
+      def self.for(markdown_renderer, editor: false)
+        new(display: markdown_renderer.available? == true, editor: editor == true)
       end
     end
   end

data/lib/samagotchi/web/editor.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "../log"
+
+module Samagotchi
+  module Web
+    # web.editor: the URL a ref's click opens in this machine's editor, as a
+    # template with {path} (the file's absolute path, each segment encoded
+    # by the page) and an optional {line}. A preset name, or a template of
+    # one's own; "none" (or an unknown name) turns refs off.
+    module Editor
+      PRESETS = {
+        "vscode" => "vscode://file{path}:{line}",
+        "vscode-insiders" => "vscode-insiders://file{path}:{line}",
+        "cursor" => "cursor://file{path}:{line}",
+        "zed" => "zed://file{path}:{line}"
+      }.freeze
+      NONE = "none"
+
+      module_function
+
+      # @param value [String, nil] the web.editor setting
+      # @return [String, nil] the URL template; nil for none. A value that
+      #   is neither a preset nor has {path} logs a warning and is none.
+      def template(value)
+        text = value.to_s.strip
+        return text if text.include?("{path}")
+
+        name = text.downcase
+        return nil if name.empty? || name == NONE
+        return PRESETS[name] if PRESETS.key?(name)
+
+        Log.warn(:web, "editor_unknown", value: text)
+        nil
+      end
+    end
+  end
+end

data/lib/samagotchi/web/message_parts.rb

@@ -3,7 +3,7 @@
 require_relative "../model_profile"
 require_relative "../tool_call_parser"
 require_relative "../tool_activity"
-require_relative "../tool_view"
+require_relative "../tool_row_fields"
 require_relative "../llm/native_tool_normalizer"
 require_relative "../tools/builtins"
 require_relative "../image_store"
@@ -231,15 +231,10 @@ module Samagotchi
         name = call[:name].to_s
         params = shown.is_a?(String) ? shown : ToolActivity.tool_activity_params(name, call, registry: registry)
         part = { tool: name, params: params.to_s }
-        title = ToolActivity.tool_title(name, call, cwd: cwd)
-        part[:title] = title if title
-        # The name the model called it by when that was an alias's (the
-        # saved call is rebuilt by BuiltinCalls, which sets it again).
-        part[:called_as] = call[:called_as] if call[:called_as]
-        # Built from the saved call (never saved itself), so older sessions
-        # get it too.
-        view = ToolView.for(name, call)&.to_h
-        part[:view] = view if view
+        # Its row fields (ToolRowFields: title, called_as, view, ref), built from the saved
+        # call (never saved themselves), so older sessions get them too. The
+        # saved call is rebuilt by BuiltinCalls, which sets called_as again.
+        part.merge!(ToolRowFields.for(name, call, cwd: cwd))
         part[:label] = label if label.is_a?(String) && !label.empty?
         unless output.nil?
           part[:output] = output.length > OUTPUT_MAX ? output[0, OUTPUT_MAX] : output

data/lib/samagotchi/web/public/activity.js

@@ -30,6 +30,32 @@ export function newActivity() {
   return { rows: [] };
 }
 
+// A row's fields beyond its params, as the server's ToolRowFields lists
+// them; each list is copied in one place per path (addStarted, addCompleted's
+// synthesized row, turn_events.js snapshotEvents), so a new field is added
+// here. ACTIVITY_FIELDS: top-level on tool_call_started, inside `activity`
+// on tool_call_completed. EVENT_FIELDS: top-level on both.
+//   title: what the call did in a few words (the server's tool title: a
+//     project-relative path, a command without its "cd … &&"); rows show
+//     it in place of the params when there is one.
+//   called_as: the name the model called the tool by when it was an
+//     alias's ("bash" run as execute); the row says so.
+//   view: the call's full arguments for the expanded row and the hovers
+//     (the server's ToolView: an execute/task_create's command, its cwd).
+//   ref: what the row traces to (the server's FileRef: {kind: "file",
+//     path, line?, end_line?}, the file a file tool touched), which
+//     refs.js makes the row's title and diff lines open.
+export const ACTIVITY_FIELDS = Object.freeze(["title", "called_as"]);
+export const EVENT_FIELDS = Object.freeze(["view", "ref"]);
+const ROW_FIELDS = Object.freeze([...ACTIVITY_FIELDS, ...EVENT_FIELDS]);
+
+// The +fields+ of +source+ that are set, as an object (for a spread).
+export function pickFields(source, fields) {
+  const picked = {};
+  for (const field of fields) if (source?.[field]) picked[field] = source[field];
+  return picked;
+}
+
 // Stable key for a call within a turn. iteration + call_index are both present
 // on :tool_call_started and :tool_call_completed, so the same key links a
 // "running" row to its completion.
@@ -52,9 +78,7 @@ export function addStarted(model, event = {}, now = null) {
     row.tool = event.tool || row.tool;
     row.label = event.label || row.label;
     row.params = event.params || row.params;
-    row.title = event.title || row.title;
-    row.called_as = event.called_as || row.called_as;
-    row.view = event.view || row.view;
+    for (const field of ROW_FIELDS) row[field] = event[field] || row[field];
     markStart(row, event, now);
     return { row, created: false };
   }
@@ -65,16 +89,8 @@ export function addStarted(model, event = {}, now = null) {
     tool: event.tool || "tool",
     label: event.label || null,
     params: event.params || "",
-    // What the call did in a few words (the server's tool title: a
-    // project-relative path, a command without its "cd … &&"); rows show it
-    // in place of the params when there is one.
-    title: event.title || null,
-    // The name the model called the tool by when it was an alias's ("bash"
-    // run as execute); the row says so.
-    called_as: event.called_as || null,
-    // The call's full arguments for the expanded row and the hovers (the
-    // server's ToolView: an execute/task_create's command, its cwd).
-    view: event.view || null,
+    // ACTIVITY_FIELDS and EVENT_FIELDS (above), null when unset.
+    ...Object.fromEntries(ROW_FIELDS.map((field) => [field, event[field] || null])),
     status: ROW_STATUS.RUNNING,
     output: "",
     output_truncated: false,
@@ -107,9 +123,8 @@ export function addCompleted(model, event = {}, now = null) {
       tool: event.tool,
       label: event.label,
       params: event.activity?.params || "",
-      title: event.activity?.title,
-      called_as: event.activity?.called_as,
-      view: event.view,
+      ...pickFields(event.activity, ACTIVITY_FIELDS),
+      ...pickFields(event, EVENT_FIELDS),
     });
     row = synthesized.row;
   }
@@ -117,8 +132,10 @@ export function addCompleted(model, event = {}, now = null) {
   row.output = event.output || "";
   row.output_truncated = !!event.output_truncated;
   if (event.activity?.params) row.params = event.activity.params;
-  if (event.activity?.title) row.title = event.activity.title;
-  if (event.activity?.called_as) row.called_as = event.activity.called_as;
+  // The completed event carries the title (ACTIVITY_FIELDS) in its activity.
+  Object.assign(row, pickFields(event.activity, ACTIVITY_FIELDS));
+  // A grep that found nothing (status ok): the row says "no match".
+  if (event.activity?.no_match) row.no_match = true;
   // The images the tool returned (a reload in the turn view draws them from
   // the saved parts, turn_html.js toolRowHtml).
   if (event.images?.length) row.images = event.images;