samagotchi 0.58.0 → 0.60.0

data/lib/samagotchi/prompt_files.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require_relative "memory_paths"
+
+module Samagotchi
+  # The files whose text goes into the system prompt as they are
+  # (SystemPrompt): which AGENTS.md files a cwd loads, and how a file
+  # becomes a prompt section.
+  module PromptFiles
+    AGENTS_FILE = "AGENTS.md"
+
+    AGENTS_HEADER = "Project specific description:"
+
+    # A file's text as the prompt carries it: +path+ absolute, +text+ the
+    # section with its header.
+    Section = Data.define(:path, :text)
+
+    module_function
+
+    # The AGENTS.md files a session in +cwd+ loads, as absolute paths,
+    # outermost first: inside a git work tree every one from its top (a
+    # linked worktree's own checkout) down to the cwd; outside a repository
+    # only the cwd's ([] with none).
+    # @param cwd [String] where the prompt is built (Dir.pwd, not the
+    #   session's working directory: /tmp vs /private/tmp would change the
+    #   prompt bytes)
+    # @return [Array<String>]
+    def agents_paths(cwd)
+      chain_dirs(cwd).map { |dir| File.join(dir, AGENTS_FILE) }.select { |path| File.file?(path) }
+    end
+
+    # The sections of the AGENTS.md chain (#agents_paths) with text: the
+    # first keeps the plain header (a one-file session's prompt is as it
+    # always was), each further one names its directory relative to the
+    # work tree top ("Project specific description for pkg/:").
+    # @return [Array<Section>]
+    def agents_sections(cwd)
+      top = MemoryPaths.work_tree_root(cwd)
+      sections = []
+      agents_paths(cwd).each do |path|
+        dir = File.dirname(path)
+        header = sections.empty? ? AGENTS_HEADER : "Project specific description for #{relative_dir(dir, top) || dir}/:"
+        text = section(path, header)
+        sections << Section.new(path: path, text: text) if text
+      end
+      sections
+    end
+
+    # The directories whose AGENTS.md a session in +cwd+ reads, outermost first.
+    def chain_dirs(cwd)
+      cwd = File.expand_path(cwd)
+      top = MemoryPaths.work_tree_root(cwd)
+      return [cwd] unless top
+
+      rel = relative_dir(cwd, top)
+      return [top] if rel == "."
+      # A cwd the walk up didn't reach from (not expected): only its own and the top's.
+      return [top, cwd] if rel.nil?
+
+      parts = rel.split("/")
+      [top] + parts.each_index.map { |i| File.join(top, *parts[0..i]) }
+    end
+
+    # +dir+ relative to +top+ ("." for the top itself), nil when it isn't under it.
+    def relative_dir(dir, top)
+      return "." if dir == top
+
+      prefix = top.end_with?("/") ? top : "#{top}/"
+      dir.start_with?(prefix) ? dir.delete_prefix(prefix) : nil
+    end
+
+    # How a prompt file is named in the prompt and /stats: relative to the
+    # work tree +top+ when inside it, else with ~ for the home directory.
+    # @return [String]
+    def display_path(path, top:)
+      rel = top && relative_dir(path, top)
+      return rel if rel && rel != "."
+
+      home = Dir.home
+      path.start_with?("#{home}/") ? "~#{path.delete_prefix(home)}" : path
+    rescue ArgumentError
+      path
+    end
+
+    # A chi --append-system-prompt value: [absolute path, nil], or
+    # [absolute path, the reason it can't be used].
+    # @param cwd [String] the shell's cwd the value is relative to
+    # @return [Array(String, String)]
+    def check_cli_file(value, cwd: Dir.pwd)
+      begin
+        path = File.expand_path(value.to_s, cwd)
+      rescue ArgumentError
+        # A quoted "~nosuchuser/x" reaches chi unexpanded.
+        return [value.to_s, "no such user"]
+      end
+      reason = if !File.exist?(path) then "no such file"
+               elsif !File.file?(path) then "not a file"
+               elsif !File.readable?(path) then "can't be read"
+               end
+      [path, reason]
+    end
+
+    # Text this long goes into every request: chi warns once, at start.
+    LARGE_CHARS = 32_000
+
+    # The number of chars of +path+ when above LARGE_CHARS, else nil.
+    # @return [Integer, nil]
+    def large_size(path)
+      chars = File.read(path, encoding: "UTF-8").length
+      chars > LARGE_CHARS ? chars : nil
+    rescue StandardError
+      nil
+    end
+
+    # +path+'s text under +header+ ("<header>\n<text>", stripped); nil when
+    # the file is empty or can't be read.
+    # @return [String, nil]
+    def section(path, header)
+      content = File.read(path, encoding: "UTF-8").strip
+      return nil if content.empty?
+
+      "#{header}\n#{content}"
+    rescue StandardError
+      nil
+    end
+  end
+end

data/lib/samagotchi/ref.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module Samagotchi
+  # One thing a click on a ref can do besides the kind's own (the web keeps
+  # those per kind, refs.js REF_ACTIONS): open +url+ in a new tab, shown as
+  # +label+ in the ref's menu. A plugin names it ("PR diff", "Open in Jira").
+  # The URL is http(s) only, checked here and again in the page
+  # (refs.js httpUrl): the page opens it as is, so a javascript:, data: or
+  # editor URL never gets there.
+  RefAction = Data.define(:id, :label, :url) do
+    # @raise [ArgumentError] an empty id or label, or a URL that isn't an
+    #   http(s) one with a host, at most MAX_URL characters
+    def initialize(id:, label:, url:)
+      id = id.to_s.strip
+      label = label.to_s.strip
+      url = url.to_s.strip
+      raise ArgumentError, "a ref action needs an id" if id.empty?
+      raise ArgumentError, "a ref action needs a label" if label.empty?
+      raise ArgumentError, "a ref action's url must be http(s) with a host, at most #{RefAction::MAX_URL} characters" unless RefAction.http_url?(url)
+
+      super
+    end
+  end
+
+  class RefAction
+    MAX_URL = 2_000
+
+    # @return [Boolean] +url+ is an http or https URL with a host
+    def self.http_url?(url)
+      return false if url.length > MAX_URL
+
+      uri = URI.parse(url)
+      uri.is_a?(URI::HTTP) && !uri.host.to_s.empty?
+    rescue URI::InvalidURIError
+      false
+    end
+
+    # @param value [RefAction, Hash] a plugin's {id:, label:, url:} (String
+    #   or Symbol keys)
+    # @raise [ArgumentError] anything else, or an invalid action
+    def self.from(value)
+      return value if value.is_a?(RefAction)
+      raise ArgumentError, "a ref action is a Hash {id:, label:, url:}" unless value.is_a?(Hash)
+
+      value = value.transform_keys(&:to_sym)
+      new(id: value[:id], label: value[:label], url: value[:url])
+    end
+  end
+
+  # A ref as data: a kind, a target, an optional label and the plugins'
+  # extra actions (RefAction), for a UI to trace it. The kind's own actions
+  # are the UI's (a file ref keeps the editor, show in turn and copy), so
+  # +actions+ only adds to them.
+  # - +kind+ "file": +target+ {path:, line:, end_line:}, the lines only when
+  #   positive, the end only past the start (FileRef's shape).
+  # - Any other kind ("issue", "commit", …): +target+ {id:}. The page shows
+  #   its +label+ (or the text it matched) and runs its first action.
+  # +to_h+ is the shape the page reads (refs.js bindRef). FileRef stays the
+  # rows' own ref; this is the one a plugin gives.
+  Ref = Data.define(:kind, :target, :label, :actions) do
+    # @raise [ArgumentError] a kind that isn't a short lowercase word, a
+    #   target without its kind's key, a non-list of actions or a bad action
+    def initialize(kind:, target:, label: nil, actions: [])
+      kind = kind.to_s
+      raise ArgumentError, "a ref's kind is a short lowercase word (#{kind.inspect})" unless Ref::KIND.match?(kind)
+      raise ArgumentError, "a ref's actions are a list" unless actions.nil? || actions.is_a?(Array)
+
+      label = label.to_s.strip
+      super(kind: kind, target: Ref.target_for(kind, target), label: label.empty? ? nil : label,
+            actions: Array(actions).map { |action| RefAction.from(action) }.freeze)
+    end
+
+    # @return [Hash] {kind:, target:, label:, actions: [{id:, label:, url:}]},
+    #   no label when there is none
+    def to_h = { kind: kind, target: target, label: label, actions: actions.map(&:to_h) }.compact
+  end
+
+  class Ref
+    KIND = /\A[a-z][a-z0-9_-]{0,31}\z/
+    # FileRef::KIND, not required here (it loads the file tools).
+    FILE = "file"
+
+    # A plugin's {kind:, target:, label:, actions:} (String or Symbol keys).
+    # @raise [ArgumentError] as +new+
+    def self.from(value)
+      raise ArgumentError, "a ref is a Hash {kind:, target:, label:, actions:}" unless value.is_a?(Hash)
+
+      value = value.transform_keys(&:to_sym)
+      new(kind: value[:kind], target: value[:target], label: value[:label], actions: value[:actions] || [])
+    end
+
+    # +kind+'s target from +raw+: a file's path and lines, any other kind's id.
+    # @raise [ArgumentError] not a Hash, or without the kind's key
+    def self.target_for(kind, raw)
+      raise ArgumentError, "a ref's target is a Hash" unless raw.is_a?(Hash)
+
+      raw = raw.transform_keys(&:to_sym)
+      kind == FILE ? file_target(raw) : { id: required(raw[:id], :id) }.freeze
+    end
+
+    def self.file_target(raw)
+      line = positive(raw[:line])
+      end_line = line && positive(raw[:end_line])
+      { path: required(raw[:path], :path), line: line, end_line: end_line && end_line > line ? end_line : nil }.compact.freeze
+    end
+    private_class_method :file_target
+
+    def self.required(value, key)
+      value = value.to_s.strip
+      raise ArgumentError, "a ref's target needs #{key}" if value.empty?
+
+      value
+    end
+    private_class_method :required
+
+    def self.positive(value)
+      number = Integer(value.to_s.strip, exception: false)
+      number&.positive? ? number : nil
+    end
+    private_class_method :positive
+  end
+end

data/lib/samagotchi/send_command.rb

@@ -586,7 +586,7 @@ module Samagotchi
       outcome = Delivery.cut?(delivery) ? ack["cut"].to_s : ""
       return " (goes in at the running turn's next step)" unless CUT_OUTCOMES.include?(outcome)
 
-      " #{TerminalUI::Formatting.steer_cut_note(outcome.to_sym)}"
+      " #{TerminalUI::Formatting.steer_cut_note(outcome.to_sym, ack["cut_after"])}"
     end
 
     # More keys for --format json, with --cut only (the line is unchanged

data/lib/samagotchi/session.rb

@@ -53,6 +53,15 @@ module Samagotchi
     # from it (--mute): the worker rebuilds the same prompt on a respawn.
     # Names as given; the engine normalizes them.
     attr_accessor :preloaded_memory_names, :muted_memory_names
+    # The files chi --append-system-prompt put into the session's system
+    # prompt (absolute paths; config.yml's append_system_prompt: entries
+    # aren't stored): kept on respawns, copied by a fork and a continue
+    # (SessionSetup).
+    attr_reader :appended_prompt_files
+
+    def appended_prompt_files=(paths)
+      @appended_prompt_files = Array(paths).map(&:to_s).reject(&:empty?).uniq
+    end
     # The model notes the session's system prompt carried at its last build
     # (Array<PromptNote>: name, scope, chars, digest; ModelNotes), set by the
     # Engine at each build (a start, a resume's or a woken worker's first
@@ -182,7 +191,7 @@ module Samagotchi
                    used_memory_names: [], project_root: nil,
                    preloaded_memory_names: [], muted_memory_names: [], parent_id: nil, scratch: false,
                    last_turn: nil, model_typed: nil, delegate: false, llm_context: nil, prompt_notes: [],
-                   continues: nil, thinking: nil, reasoning_history: nil)
+                   continues: nil, thinking: nil, reasoning_history: nil, appended_prompt_files: [])
       @id = id
       @metadata_version = metadata_version
       @mode = mode
@@ -210,6 +219,7 @@ module Samagotchi
       self.llm_context = llm_context
       self.thinking = thinking
       self.reasoning_history = reasoning_history
+      self.appended_prompt_files = appended_prompt_files
       @archived = false
     end
 
@@ -289,6 +299,7 @@ module Samagotchi
         llm_context: setup.llm_context,
         thinking: setup.thinking,
         reasoning_history: setup.reasoning_history,
+        appended_prompt_files: setup.appended_prompt_files,
         continues: continues
       )
     end
@@ -351,7 +362,8 @@ module Samagotchi
       "llm_context" => nil,
       "continues" => nil,
       "thinking" => nil,
-      "reasoning_history" => nil
+      "reasoning_history" => nil,
+      "appended_prompt_files" => []
     }.freeze
 
     # A session from a parsed session file. +messages+ false leaves the
@@ -476,7 +488,7 @@ module Samagotchi
                 when "reasoning_history" then reasoning_history_file
                 when "prompt_notes" then @prompt_notes.map(&:to_file)
                 when "last_turn" then @last_turn&.to_file
-                when "used_memory_names", "preloaded_memory_names", "muted_memory_names"
+                when "used_memory_names", "preloaded_memory_names", "muted_memory_names", "appended_prompt_files"
                   Array(instance_variable_get(:"@#{key}"))
                 else instance_variable_get(:"@#{key}")
                 end

data/lib/samagotchi/session_commands.rb

@@ -328,7 +328,9 @@ module Samagotchi
       command = text.delete_prefix(SHELL_BANG_PREFIX).strip
       return reply("!: please provide a shell command after '!'", status: :error) if command.empty?
 
-      output = Samagotchi::Tools::Execute.call(command, env: Samagotchi::Tools::Builtins.cli_model_unset)
+      # Killed at the limit, never handed over: the output goes in a user
+      # message, which no one reads a task id from (created_ids_in).
+      output = Samagotchi::Tools::Execute.call(command, env: Samagotchi::Tools::Builtins.cli_model_unset, on_timeout: :kill)
       @engine.append_messages([{ role: "user", content: "!(#{command})\n#{output}" }])
       # Rolling back past this would silently drop the command output.
       @turn_flow.note_conversation_changed
@@ -484,9 +486,9 @@ module Samagotchi
     def model_command(input)
       suffix = input.delete_prefix(MODEL_COMMAND).strip
       if suffix.empty?
-        return ["runtime model: #{model_name}#{model_note}#{served_note}#{sampling_note}#{thinking_note}#{reasoning_history_note}#{notes_note}", false] if @default_model.nil? || model_name == @engine.model_ref_for(@default_model)
+        return ["runtime model: #{model_name}#{model_note}#{served_note}#{sampling_note}#{steer_cut_after_note}#{thinking_note}#{reasoning_history_note}#{notes_note}", false] if @default_model.nil? || model_name == @engine.model_ref_for(@default_model)
 
-        return ["runtime model: #{model_name}#{model_note("default: #{@default_model}")}#{served_note}#{sampling_note}#{thinking_note}#{reasoning_history_note}#{notes_note}", false]
+        return ["runtime model: #{model_name}#{model_note("default: #{@default_model}")}#{served_note}#{sampling_note}#{steer_cut_after_note}#{thinking_note}#{reasoning_history_note}#{notes_note}", false]
       end
 
       # Parse flags: --default and --alias <name> / --alias=<name> (tolerant order)
@@ -606,6 +608,16 @@ module Samagotchi
       ""
     end
 
+    # "; steer cut: after 60 s (models: qwen)", or "; steer cut: never
+    # (hosts.splash)" for 0 or less, when the model has one configured;
+    # "" for the default.
+    def steer_cut_after_note
+      summary = @engine.steer_cut_summary
+      summary ? "; steer cut: #{summary}" : ""
+    rescue StandardError
+      ""
+    end
+
     # "; notes: model_notes_deepseek (system, 612 chars)": the model notes
     # the session's prompt carries (after a switch, the ones the new
     # model's prompt loads); "" without any.

data/lib/samagotchi/session_metrics.rb

@@ -142,9 +142,13 @@ module Samagotchi
       :cuts,
       :capped,
       :model,
-      # The turn the user started by answering the step-limit question with
-      # Continue (:turn_started's +continue+); its record carries it.
+      # A turn with no prompt of its own (:turn_started's +continue+): a
+      # step-limit Continue, a reminder's or a wake's turn; its record
+      # carries it.
       :continue,
+      # The turn the user started by answering the step-limit question with
+      # Continue (:turn_started's +resumed+): it resumed the run before it.
+      :resumed,
       :id,
       :started_at,
       :started_monotonic,
@@ -558,6 +562,7 @@ module Samagotchi
           capped: 0,
           model: nil,
           continue: event[:continue] ? true : false,
+          resumed: event[:resumed] ? true : false,
           id: event[:turn_id] || SecureRandom.uuid,
           started_at: now.iso8601(3),
           started_monotonic: monotonic_time,
@@ -597,6 +602,7 @@ module Samagotchi
           # Every record says, so the report can tell a file with no Continue
           # from one written before the mark.
           record[:continue] = @turn.continue
+          record[:resumed] = @turn.resumed
           record.merge!(turn_token_fields(@turn))
           @turn_records << record
           count_turn(record)

data/lib/samagotchi/session_setup.rb

@@ -10,15 +10,20 @@ module Samagotchi
   # (SessionManager.spawn_session, a continue, a plugin's fork, the web's
   # create, chi send --new): +llm_context+ is an LLMContextOverride or nil,
   # +thinking+ a level Symbol (Thinking.session_level) or nil,
-  # +reasoning_history+ a level Symbol (ReasoningHistory.session_level) or nil.
+  # +reasoning_history+ a level Symbol (ReasoningHistory.session_level) or nil,
+  # +appended_prompt_files+ the absolute paths chi --append-system-prompt
+  # named (their text goes into the system prompt; [] with none).
   #
   # It doesn't save itself: the session keeps each setting in its own field
   # and file key, and resolves it on its own. A delegate child starts
   # without one; a continue and a fork copy their session's (.of).
-  SessionSetup = Data.define(:llm_context, :thinking, :reasoning_history) do
-    def initialize(llm_context: nil, thinking: nil, reasoning_history: nil) = super
+  SessionSetup = Data.define(:llm_context, :thinking, :reasoning_history, :appended_prompt_files) do
+    def initialize(llm_context: nil, thinking: nil, reasoning_history: nil, appended_prompt_files: [])
+      super(llm_context: llm_context, thinking: thinking, reasoning_history: reasoning_history,
+            appended_prompt_files: Array(appended_prompt_files).map(&:to_s).freeze)
+    end
 
-    def empty? = llm_context.nil? && thinking.nil? && reasoning_history.nil?
+    def empty? = llm_context.nil? && thinking.nil? && reasoning_history.nil? && appended_prompt_files.empty?
 
     # A session's own setup, for a session that starts from it.
     # @param session [Session, nil]
@@ -26,7 +31,8 @@ module Samagotchi
     def self.of(session)
       return new if session.nil?
 
-      new(llm_context: session.llm_context, thinking: session.thinking, reasoning_history: session.reasoning_history)
+      new(llm_context: session.llm_context, thinking: session.thinking, reasoning_history: session.reasoning_history,
+          appended_prompt_files: session.appended_prompt_files)
     end
   end
 end

data/lib/samagotchi/steer_cut.rb

@@ -30,19 +30,23 @@ module Samagotchi
     end
 
     # +clock+: monotonic seconds; +controller+: the running turn's cancel
-    # controller (nil between turns), read only when a cut is due.
-    def initialize(clock:, controller:)
+    # controller (nil between turns), read only when a cut is due;
+    # +cut_after+: seconds a thinking-only generation may stream before a
+    # cut, called on every check (the Engine passes the model's own
+    # SteerCutAfter; the global steer.cut_after here).
+    def initialize(clock:, controller:, cut_after: -> { self.class.cut_after })
       # What the running generation streams: whether a steer may cut it.
       @phase = GenerationPhase.new(clock: clock)
       # A message that may cut it but came too early: it cuts later.
       @waiting = WaitingSteer.new
+      @cut_after = cut_after
       @controller = controller
     end
 
     # A message for the running turn from +source+ (Steer.source_for_client:
     # nil for the user, "chi_send", "parent_agent") cuts the streaming
-    # generation when it has streamed only thinking for steer.cut_after
-    # seconds (GenerationPhase): the loops' cut path (CutPolicy) then starts
+    # generation when it has streamed only thinking for cut_after seconds
+    # (GenerationPhase): the loops' cut path (CutPolicy) then starts
     # the step again with the message, no nudge, no retry spent. Too early,
     # the message waits (WaitingSteer) and cuts once the thinking passes it
     # (#recheck, on each thinking chunk), unless a boundary hands it to the
@@ -52,13 +56,13 @@ module Samagotchi
     # before queueing it. Outside any lock; a cut that lands just after the
     # generation ended is harmless (the loop re-asks).
     # @return [Symbol] :now (a generation was cut now), :waits (the message
-    #   waits for the thinking to pass steer.cut_after), or :off (cutting
+    #   waits for the thinking to pass cut_after), or :off (cutting
     #   off for this source: a plugin, no turn, cut_after 0, a generation
     #   that isn't thinking-only, or a drain already took the message)
     def cut_for_steer(source, epoch: nil)
       return :off unless Steer.cuts?(source)
 
-      after = self.class.cut_after
+      after = @cut_after.call.to_i
       return :off unless after.positive?
 
       ctrl = @controller.call
@@ -107,11 +111,11 @@ module Samagotchi
     private
 
     # A thinking chunk streamed: a waiting message cuts once the thinking
-    # passes steer.cut_after.
+    # passes cut_after.
     def recheck
       return unless @waiting.waiting?
 
-      after = self.class.cut_after
+      after = @cut_after.call.to_i
       return unless after.positive? && @phase.cuttable?(after)
 
       source = @waiting.take

data/lib/samagotchi/steer_cut_after.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative "config"
+
+module Samagotchi
+  # How long a message sent as a cut waits for the generation it came during:
+  # the seconds a generation must have streamed only thinking before a cut may
+  # land (SteerCut), one per model, host or run, like Thinking for the level.
+  #
+  # Order (#resolve): the env (SAMAGOTCHI_STEER_CUT_AFTER), then
+  # models.<key>.steer_cut_after, hosts.<name>.steer_cut_after,
+  # steer.cut_after in config.yml, then 20. 0 = never cut (a slow local
+  # thinker is left alone); it is a value, not an unset.
+  module SteerCutAfter
+    KEY = "steer_cut_after"
+    ENV_KEY = "SAMAGOTCHI_STEER_CUT_AFTER"
+    DEFAULT = 20
+
+    module_function
+
+    # A `steer_cut_after:` setting (hosts: entry or models: entry): whole
+    # seconds ≥ 0 (0 = never), nil when unset; anything else warns once,
+    # naming +where+, and counts as unset.
+    # @return [Integer, nil]
+    def seconds(value, where)
+      return nil if value.nil?
+
+      text = value.to_s.strip
+      return text.to_i if text.match?(/\A\d+\z/)
+
+      ConfigFile.warn_once "Warning: #{where}: steer_cut_after must be whole seconds (0 = never); ignored"
+      nil
+    end
+
+    # The seconds for +target+ and where they came from
+    # ("SAMAGOTCHI_STEER_CUT_AFTER", "models: qwen", "hosts.splash",
+    # "steer.cut_after"; nil for the default).
+    # @param target [HostRegistry::ModelTarget]
+    # @param names [Array<String>] the model's lookup names (HostRegistry#lookup_names)
+    # @param models [Hash{String => ModelSettings}, nil] ConfigFile.model_settings (specs)
+    # @return [Array(Integer, String|nil)]
+    def resolve(target, names:, models: nil)
+      value, origin = Config.get_with_origin("steer.cut_after")
+      return [value.to_i, ENV_KEY] if origin == :env
+
+      models ||= begin
+        ConfigFile.model_settings
+      rescue StandardError
+        {}
+      end
+      setting = ConfigFile.model_setting(names, :steer_cut_after, models: models)
+      return [setting.value, "models: #{setting.key}"] if setting
+
+      host = target.entry.steer_cut_after
+      return [host, "hosts.#{target.entry.name}"] unless host.nil?
+
+      return [value.to_i, "steer.cut_after"] if origin == :file
+
+      [DEFAULT, nil]
+    end
+
+    # "after 60 s (models: qwen)"; 0 or less is "never (hosts.splash)".
+    # No source: just the seconds.
+    def label(seconds, source)
+      text = seconds.to_i <= 0 ? "never" : "after #{seconds} s"
+      source ? "#{text} (#{source})" : text
+    end
+  end
+end