samagotchi 0.2.0

data/lib/samagotchi/web/markdown_renderer.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+require "uri"
+
+module Samagotchi
+  module Web
+    class MarkdownRenderer
+      WARNING = "Markdown rendering is enabled, but the optional commonmarker gem is not installed. Install it with: gem install commonmarker"
+      # NOTE: `span` is allowed because the syntax highlighter (commonmarker/syntect)
+      # emits inline-styled <span>s; keeping it lets highlighting render.
+      ALLOWED_ELEMENTS = %w[a blockquote br code del em h1 h2 h3 h4 h5 h6 hr li ol p pre s strong span table tbody td th thead tr ul].freeze
+      DROP_ELEMENTS = %w[iframe object script style svg].freeze
+      ALLOWED_PROTOCOLS = %w[http https mailto].freeze
+
+      def initialize(enabled: false)
+        @enabled = enabled
+      end
+
+      def enabled?
+        @enabled
+      end
+
+      def available?
+        enabled? && load_bundled_commonmarker!
+      end
+
+      def warning
+        WARNING if enabled? && !load_bundled_commonmarker!
+      end
+
+      def render(markdown)
+        return nil unless available?
+
+        html = Commonmarker.to_html(markdown.to_s, options: {
+          render: { escape: true }, # escape raw HTML from source; highlighter output is still emitted
+          extension: { header_ids: nil },
+        })
+        return nil unless html
+
+        sanitize(html)
+      end
+
+      private
+
+      def load_bundled_commonmarker!
+        return @commonmarker_available unless @commonmarker_available.nil?
+
+        require "commonmarker"
+        @commonmarker_available = true
+      rescue LoadError
+        @commonmarker_available = false
+      end
+
+      def sanitize(html)
+        fragment = Nokogiri::HTML5.fragment(html)
+        fragment.traverse do |node|
+          next unless node.element?
+
+          if DROP_ELEMENTS.include?(node.name)
+            node.remove
+          elsif !ALLOWED_ELEMENTS.include?(node.name)
+            node.replace(node.children)
+          else
+            sanitize_attributes(node)
+          end
+        end
+        fragment.to_html
+      end
+
+      def sanitize_attributes(node)
+        node.attribute_nodes.each do |attribute|
+          next if allowed_attribute?(node, attribute.name)
+          node.remove_attribute(attribute.name)
+        end
+        return unless node.name == "a"
+
+        href = node["href"].to_s.strip
+        unless safe_href?(href)
+          node.remove_attribute("href")
+          return
+        end
+        node["target"] = "_blank"
+        node["rel"] = "noopener noreferrer"
+      end
+
+      # The syntax highlighter emits inline `style=` on <span>/<pre>/<code>. Those
+      # values come from the (trusted) theme, not user input, and raw HTML from the
+      # markdown source is already escaped by commonmarker (escape: true), so style
+      # attributes are safe to keep on these elements only.
+      def allowed_attribute?(node, name)
+        return true if name == "style" && %w[span pre code].include?(node.name)
+
+        node.name == "a" && %w[href title].include?(name)
+      end
+
+      def safe_href?(href)
+        return true if href.start_with?("#", "/")
+
+        uri = URI.parse(href)
+        uri.scheme && ALLOWED_PROTOCOLS.include?(uri.scheme.downcase)
+      rescue URI::InvalidURIError
+        false
+      end
+    end
+  end
+end

data/lib/samagotchi/web/message_parts.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+require_relative "../model_profile"
+require_relative "../tool_call_parser"
+require_relative "../tool_activity"
+require_relative "../llm/native_tool_normalizer"
+require_relative "../tools/builtins"
+require_relative "../image_store"
+
+module Samagotchi
+  module Web
+    # What a saved assistant message did, for the web turn view's reload: its
+    # thinking and its tool calls (name, the params line the live row shows,
+    # the output from the tool_response messages after it). Two storage
+    # shapes, best effort:
+    #   * the native loop (a profile, llama.cpp): the raw response as content
+    #     (thinking + tool-call markup, Qwen or Gemma), then one tool_response
+    #     whose content joins every call's output with "\n\n---\n\n";
+    #   * the chat loop (api: openai): the text without thinking, the host's
+    #     reasoning as +thinking+ (older sessions have none), the calls as
+    #     tool_calls ({id, name, arguments}), then one tool_response per call
+    #     (tool_call_id).
+    # A message that can't be read gives no parts, never an error.
+    #
+    # A call's images (a read image, a plugin or MCP tool's) are on its
+    # tool_response: chat, per call; native, one list for every call, split
+    # by the saved image_counts (older sessions without them: only a lone
+    # call gets them).
+    #
+    # A plugin tool's params are what its live row showed (its preview),
+    # saved with the result as tool_params (native: one per call, chat: one
+    # per result); its label ("chrome: screenshot") likewise as tool_labels,
+    # the part's label:. The web server has no Engine and runs no plugins, so a
+    # result without them (older sessions) falls back to the given
+    # registry: the built-ins', and a plugin tool's arguments as key="value"
+    # from the parsers' args:, as the live row shows them for a tool
+    # without a preview.
+    module MessageParts
+      JOINER = "\n\n---\n\n"
+      # A joined output's pieces each start with "[tool]": split there first,
+      # so an output that holds the joiner itself stays whole.
+      JOINER_BEFORE_TAG = /\n\n---\n\n(?=\[)/
+      # The row shows 300 chars and the rest on hover; a read of a big file
+      # would otherwise ride along with every reload.
+      OUTPUT_MAX = 2000
+
+      QWEN_THINK = %r{<think>(.*?)</think>}m
+      QWEN_OPEN_THINK = %r{\A(.*?)</think>}m # the template opened the block
+      GEMMA_THOUGHT = /<\|channel>thought(.*?)(?:<channel\|>|\z)/m
+
+      CallRef = Struct.new(:name, :arguments)
+
+      module_function
+
+      # @param message [Hash] a saved model message (symbol or string keys)
+      # @param responses [Array<Hash>] the tool_response messages after it
+      # @param registry [Tools::Registry] the session's tools
+      # @return [Hash, nil] { thinking:, tools: [{ tool:, params:, output:,
+      #   output_truncated:, images: }] } with only what it found; nil for nothing
+      def for_message(message, responses, registry: Tools::Builtins.default)
+        content = field(message, :content).to_s
+        calls = field(message, :tool_calls)
+        tools = if calls.is_a?(Array) && !calls.empty?
+                  native_tools(calls, responses, registry)
+                else
+                  markup_tools(content, responses, registry)
+                end
+        parts = {}
+        thinking = [field(message, :thinking).to_s.strip, thinking_of(content)].reject(&:empty?).join("\n\n")
+        parts[:thinking] = thinking unless thinking.empty?
+        parts[:tools] = tools unless tools.empty?
+        parts.empty? ? nil : parts
+      rescue StandardError
+        nil
+      end
+
+      def thinking_of(content)
+        blocks = content.scan(QWEN_THINK).flatten
+        if blocks.empty? && !content.include?("<think>") && (open = content[QWEN_OPEN_THINK, 1])
+          blocks = [open]
+        end
+        blocks += content.scan(GEMMA_THOUGHT).flatten
+        blocks.map(&:strip).reject(&:empty?).join("\n\n")
+      end
+
+      def markup_tools(content, responses, registry)
+        calls = []
+        calls.concat(ToolCallParser::Qwen.new(ModelProfile.qwen36).parse(content)) if content.include?("<tool_call>")
+        calls.concat(ToolCallParser::Gemma.new(ModelProfile.gemma4).parse(content)) if content.include?("<|tool_call>")
+        return [] if calls.empty?
+
+        joined = responses.empty? ? nil : responses.map { |r| field(r, :content).to_s }.join(JOINER)
+        outputs = split_outputs(joined, calls.length)
+        shown = saved_list(responses, :tool_params, calls.length)
+        labels = saved_list(responses, :tool_labels, calls.length)
+        images = split_images(responses, calls.length)
+        calls.each_with_index.map do |call, i|
+          tool_part(call, outputs[i], registry, shown[i], images[i], label: labels[i])
+        end
+      end
+
+      # A per-call list saved with the joined result(s), or none when its
+      # length doesn't match the calls.
+      def saved_list(responses, key, count)
+        list = responses.flat_map { |r| Array(field(r, key)) }
+        list.length == count ? list : []
+      end
+
+      # Each call's images from the joined tool_response(s).
+      def split_images(responses, count)
+        images = responses.flat_map { |r| Array(field(r, :images)) }
+        return [] if images.empty?
+
+        counts = responses.flat_map { |r| Array(field(r, :image_counts)) }
+        return count == 1 ? [images] : [] unless counts.length == count && counts.sum == images.length
+
+        counts.map { |n| images.shift(n) }
+      end
+
+      def native_tools(calls, responses, registry)
+        by_id = responses.to_h { |r| [field(r, :tool_call_id), r] }
+        calls.each_with_index.map do |raw, i|
+          ref = CallRef.new(field(raw, :name).to_s, field(raw, :arguments))
+          call = LLM::NativeToolNormalizer.normalize(ref) || { name: ref.name }
+          response = by_id[field(raw, :id)] || (field(responses[i], :tool_call_id).nil? ? responses[i] : nil)
+          tool_part(call, response && field(response, :content).to_s, registry, field(response, :tool_params),
+                    response && field(response, :images), label: field(response, :tool_labels))
+        end
+      end
+
+      # +count+ outputs from a joined tool_response: the "[tool]"-tagged
+      # split when it gives the right count, else the plain one; extra pieces
+      # stay with the last call, missing ones are nil.
+      def split_outputs(joined, count)
+        return [] if joined.nil?
+        return [joined] if count == 1
+
+        pieces = joined.split(JOINER_BEFORE_TAG, -1)
+        pieces = joined.split(JOINER, -1) if pieces.length != count
+        return pieces if pieces.length == count
+
+        head = pieces.first(count - 1)
+        rest = pieces.drop(count - 1)
+        head + [rest.empty? ? nil : rest.join(JOINER)]
+      end
+
+      # +shown+ is the saved params line, when it is a String.
+      def tool_part(call, output, registry, shown = nil, images = nil, label: nil)
+        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 }
+        part[:label] = label if label.is_a?(String) && !label.empty?
+        unless output.nil?
+          part[:output] = output.length > OUTPUT_MAX ? output[0, OUTPUT_MAX] : output
+          part[:output_truncated] = true if output.length > OUTPUT_MAX
+        end
+        refs = Array(images).select { |ref| ref.is_a?(Hash) }
+        part[:images] = refs.map { |ref| ImageStore.symbolize(ref).slice(:file, :name, :width, :height) } unless refs.empty?
+        part
+      end
+
+      def field(hash, key)
+        return nil unless hash.is_a?(Hash)
+
+        hash.key?(key) ? hash[key] : hash[key.to_s]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,100 @@
+// Pure model for the per-turn tool/memory "activity" panel.
+//
+// This module has NO DOM dependencies: it maintains a plain-object state
+// (rows keyed by iteration:call_index, each with a status + params + output).
+// app.js owns the rendering and calls into these functions to transition row
+// state from :tool_call_started / :tool_call_completed events. Keeping the
+// state pure makes it unit-testable under `node --test` like data.js/format.js.
+
+export const ROW_STATUS = Object.freeze({
+  RUNNING: "running",
+  OK: "ok",
+  ERROR: "error",
+});
+
+// What a row shows for its tool: a plugin tool's label ("chrome:
+// screenshot", from its tool_call_started or saved with its result), else
+// the tool's name.
+export function toolName(row) {
+  return row?.label || row?.tool || "tool";
+}
+
+// Create a fresh activity model for one turn.
+export function newActivity() {
+  return { finalized: false, rows: [] };
+}
+
+// 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.
+export function rowKey(iteration, callIndex) {
+  return `${iteration ?? 0}:${callIndex ?? 0}`;
+}
+
+// Upsert a row from a :tool_call_started event. Returns { row, created }.
+// If a row with the same key already exists (duplicate start), it is reset to
+// running and updated rather than duplicated.
+export function addStarted(model, event = {}) {
+  const iteration = event.iteration ?? 0;
+  const callIndex = event.call_index ?? 0;
+  const key = rowKey(iteration, callIndex);
+  let row = model.rows.find((r) => r.key === key);
+  if (row) {
+    row.status = ROW_STATUS.RUNNING;
+    row.tool = event.tool || row.tool;
+    row.label = event.label || row.label;
+    row.params = event.params || row.params;
+    return { row, created: false };
+  }
+  row = {
+    key,
+    iteration,
+    callIndex,
+    tool: event.tool || "tool",
+    label: event.label || null,
+    params: event.params || "",
+    status: ROW_STATUS.RUNNING,
+    output: "",
+    output_truncated: false,
+  };
+  model.rows.push(row);
+  return { row, created: true };
+}
+
+// Update (or synthesize) a row from a :tool_call_completed event. Returns the row.
+// If no matching :tool_call_started was seen (e.g. a replay gap), a row is
+// created on the fly so the completion is never lost.
+export function addCompleted(model, event = {}) {
+  const iteration = event.iteration ?? 0;
+  const callIndex = event.call_index ?? 0;
+  const key = rowKey(iteration, callIndex);
+  let row = model.rows.find((r) => r.key === key);
+  if (!row) {
+    const synthesized = addStarted(model, {
+      iteration,
+      call_index: callIndex,
+      tool: event.tool,
+      label: event.label,
+      params: event.activity?.params || "",
+    });
+    row = synthesized.row;
+  }
+  row.status = event.activity?.status === "error" ? ROW_STATUS.ERROR : ROW_STATUS.OK;
+  row.output = event.output || "";
+  row.output_truncated = !!event.output_truncated;
+  if (event.activity?.params) row.params = event.activity.params;
+  // The images the tool returned (a reload in the turn view draws them from
+  // the saved parts, turn_view.js reloadRowHtml).
+  if (event.images?.length) row.images = event.images;
+  return row;
+}
+
+// Mark a turn's activity model as finalized (rows stay; rendering collapses).
+export function finalizeActivity(model) {
+  if (model) model.finalized = true;
+  return model;
+}
+
+export function activityCount(model) {
+  return model ? model.rows.length : 0;
+}

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

@@ -0,0 +1,67 @@
+// Annotations: quote a piece of the conversation into the composer.
+//
+// Selecting text in an answer, a thinking block, a tool row or one of your
+// own messages offers "Annotate", which appends a quote block to the
+// composer; the note goes under it. The message stays plain text:
+//
+//   From your thinking:
+//   > the quoted line
+//
+//   the note
+//
+// The label says where the quote came from. Thinking never reaches the
+// model's history, so without it a thinking quote reads as text the model
+// never wrote. No DOM state here beyond Element#closest/querySelector, so it
+// runs under `node --test` with stand-ins.
+
+// Where a node inside #history came from: { kind, tool, root } where root
+// is the element a selection is clipped to, or null when that part of the
+// page isn't annotatable (status lines, recaps, cards, a streaming answer).
+export function annotationSource(node) {
+  const el = node && node.nodeType === 3 ? node.parentElement : node;
+  if (!el?.closest) return null;
+  const row = el.closest(".activity-row");
+  if (row) {
+    const tool = row.querySelector(".activity-tool")?.textContent?.trim() || "tool";
+    return { kind: "tool", tool, root: row };
+  }
+  const thinking = el.closest(".thinking-body");
+  if (thinking) return { kind: "thinking", root: thinking };
+  // A step's narration in the turn view (the live one streams).
+  const step = el.closest(".gen-text");
+  if (step) return step.classList.contains("streaming") ? null : { kind: "step", root: step };
+  const own = el.closest(".bubble.user .user-message");
+  if (own) return { kind: "user", root: own };
+  const answer = el.closest(".bubble.output");
+  if (answer && !answer.classList.contains("streaming")) return { kind: "answer", root: answer };
+  return null;
+}
+
+export function sourceLabel(kind, tool) {
+  if (kind === "thinking") return "From your thinking:";
+  if (kind === "step") return "From your earlier step:";
+  if (kind === "tool") return `From the ${tool || "tool"} call:`;
+  if (kind === "user") return "From my earlier message:";
+  return null;
+}
+
+// The label and the `>` lines for +text+, ending in a blank line so the note
+// starts right under it; null when the selection holds no text.
+export function quoteBlock(text, { kind, tool } = {}) {
+  const lines = String(text ?? "")
+    .replace(/\r\n?/g, "\n")
+    .split("\n")
+    .map((l) => l.replace(/\s+$/, ""));
+  while (lines.length && !lines[0]) lines.shift();
+  while (lines.length && !lines[lines.length - 1]) lines.pop();
+  if (!lines.length) return null;
+  const label = sourceLabel(kind, tool);
+  const quoted = lines.map((l) => (l ? `> ${l}` : ">")).join("\n");
+  return `${label ? `${label}\n` : ""}${quoted}\n\n`;
+}
+
+// The composer's text with +block+ appended after a blank line.
+export function appendQuote(value, block) {
+  const before = String(value ?? "").replace(/\s+$/, "");
+  return before ? `${before}\n\n${block}` : block;
+}