insika 0.0.1 → 0.2.0

data/lib/insika/studio/forms.rb

@@ -0,0 +1,335 @@
+# frozen_string_literal: true
+
+module Studio
+  # Form → command-payload parsing for the Studio App. A mixin, NOT a
+  # standalone object: `include`d into App so every method keeps `self` == the
+  # App instance and reaches its request helpers (`presence`, `split_list`) and
+  # per-request state (`@agent`) exactly as before. Pure extraction — the bodies
+  # moved verbatim from app.rb; app_spec's POST cases are the safety net.
+  module Forms
+    def config_patch(r)
+      limits = @agent.limits.dup
+      # Always present via DEFAULT_LIMITS (tool_concurrency defaults to 1 = serial),
+      # so a blank field just keeps whatever is stored.
+      %w[turn_timeout tool_timeout tool_concurrency].each do |field|
+        v = presence(r.params[field])
+        limits[field.to_sym] = Integer(v) if v
+      end
+      # Per-agent edge overrides. Unlike the timeouts (always present via
+      # DEFAULT_LIMITS), these are OPT-IN keys: blank DELETES the override (inherit
+      # the platform edge settings); 0 explicitly disables for this agent.
+      %w[chat_rate_limit agent_token_ceiling].each do |field|
+        v = edge_int(r.params[field], field)
+        if v.nil?
+          limits.delete(field.to_sym)
+        else
+          limits[field.to_sym] = v
+        end
+      end
+      {
+        id: @agent.id,
+        model: presence(r.params["model"]),
+        provider: r.params["provider"].to_s,
+        memory: r.params["memory"] == "1",
+        limits: limits,
+        params: params_patch(r),
+        model_policy: model_policy_patch(r),
+        guardrails: guardrails_patch(r)
+      }
+    end
+
+    # Guardrails config from the form. The config form OWNS these fields,
+    # so the patch reflects the whole guardrails state. String values round-trip
+    # cleanly through the JSON store; Safety::Config normalizes on read. A blank
+    # moderator drops the key (deterministic only).
+    def guardrails_patch(r)
+      out = {
+        "input" => r.params["guardrail_input"] == "1",
+        "output" => r.params["guardrail_output"] == "1",
+        "strictness" => presence(r.params["guardrail_strictness"]) || "medium"
+      }
+      (mod = presence(r.params["guardrail_moderator"])) && (out["moderator"] = mod)
+      responses = guardrail_responses_patch(r)
+      out["responses"] = responses unless responses.empty?
+      out
+    end
+
+    # Per-category safe-reply overrides (config over convention). Only
+    # the non-blank fields are persisted; Safety::Config normalizes on read.
+    def guardrail_responses_patch(r)
+      %w[default injection sexual abuse escalate].each_with_object({}) do |cat, acc|
+        (v = presence(r.params["guardrail_response_#{cat}"])) && (acc[cat] = v)
+      end
+    end
+
+    # Per-agent generation params. The config form OWNS these fields, so
+    # the patch reflects the whole form state: a blank field drops the key (and an
+    # all-blank form clears params to {}). temperature/max_tokens MUST be Numeric —
+    # ModelSelection#apply_params guards on `numeric?` and silently skips a String —
+    # so coerce here; a malformed number is dropped rather than 500-ing the save.
+    # thinking is a reasoning-effort string (low/medium/high), applied verbatim.
+    def params_patch(r)
+      out = {}
+      t = coerce(r.params["temperature"]) { |v| Float(v) }
+      out["temperature"] = t unless t.nil?
+      m = coerce(r.params["max_tokens"]) { |v| Integer(v) }
+      out["max_tokens"] = m unless m.nil?
+      thinking = presence(r.params["thinking"])
+      out["thinking"] = thinking if thinking
+      out
+    end
+
+    # Per-agent model fence: { "allow" => [refs] } where a ref is
+    # "provider/model", "provider/*" or "model". Blank textarea -> nil (NO fence,
+    # all models — parity). Enforced on the RESOLVED model by the ModelResolver,
+    # so a per-chat pin can never escape it.
+    def model_policy_patch(r)
+      refs = split_list(r.params["model_policy_allow"])
+      refs.empty? ? nil : { "allow" => refs }
+    end
+
+    # Parses a numeric-ish form field, returning nil for blank or unparseable input
+    # (never raises — a bad value must not turn a config save into a 500).
+    def coerce(raw)
+      v = presence(raw)
+      return nil unless v
+
+      yield(v)
+    rescue ArgumentError, TypeError
+      nil
+    end
+
+    # Fields a tool CAN carry that this form does not render. The store REPLACES the
+    # record on write, so anything missing here is erased — a save that only fixed a
+    # typo in the description would silently drop them (the class of bug already
+    # paid for once). `stored` carries them through untouched.
+    UNEDITED_TOOL_FIELDS = %w[group tags halt_when].freeze
+
+    # :write_data_tool payload from the form. nested request/response;
+    # headers/query as "key=value" per line (same idiom as the MCP env —
+    # a masked secret comes back as a sentinel and is reconciled in the store).
+    # `stored` = the definition being edited (nil when creating).
+    def tool_patch(r, stored = nil)
+      preserved = (stored || {}).slice(*UNEDITED_TOOL_FIELDS).compact
+      preserved.merge(
+        name: presence(r.params["name"]),
+        description: r.params["description"].to_s,
+        parameters: parse_parameters(r.params["parameters"]),
+        request: {
+          method: presence(r.params["method"]) || "GET",
+          url: r.params["url"].to_s,
+          headers: parse_kv_lines(r.params["headers"]),
+          query: parse_kv_lines(r.params["query"]),
+          body: presence(r.params["body"])
+        },
+        response: {
+          extract: presence(r.params["extract"]) || "body_raw",
+          path: presence(r.params["path"])
+        },
+        secret_headers: split_list(r.params["secret_headers"]),
+        timeout: presence(r.params["timeout"])
+      )
+    end
+
+    # Parameters, TWO accepted syntaxes in one field (auto-detected, no mode toggle):
+    # text starting with `{` is a full JSON Schema — the only form that expresses
+    # nesting (an array of objects, a nested object); anything else is the flat
+    # pipe-delimited sugar. This is what keeps the editor from being a lossy
+    # round-trip: a nested tool renders as JSON here and saves back as the same JSON,
+    # instead of being flattened into a shape its author never wrote.
+    def parse_parameters(text)
+      s = text.to_s.strip
+      return parse_param_lines(text) unless s.start_with?("{")
+
+      begin
+        JSON.parse(s)
+      rescue JSON::ParserError => e
+        raise Insika::ValidationError, "parameters: invalid JSON Schema (#{e.message.lines.first.to_s.strip})"
+      end
+    end
+
+    # Flat sugar: one line per param, pipe-delimited (CSP forbids JS for
+    # dynamic lines; a textarea is the honest path, like the MCP env):
+    #   name | type | required|optional | description
+    def parse_param_lines(text)
+      text.to_s.each_line.filter_map do |line|
+        line = line.strip
+        next if line.empty? || line.start_with?("#")
+
+        name, type, req, desc = line.split("|", 4).map(&:strip)
+        next if name.to_s.empty?
+
+        { "name" => name, "type" => (presence(type) || "string"),
+          "required" => req.to_s.downcase != "optional", "description" => desc.to_s }
+      end
+    end
+
+    def settings_patch(r)
+      patch = {
+        "streaming" => r.params["streaming"] == "1"
+      }
+      { "request_timeout" => "request_timeout", "max_retries" => "max_retries",
+        "turn_timeout" => "turn_timeout", "tool_timeout" => "tool_timeout" }.each_key do |f|
+        v = presence(r.params[f])
+        patch[f] = Integer(v) if v
+      end
+      patch
+    end
+
+    # Edge limits — the platform rate-limit/cost layer, saved
+    # from its OWN form (a sub-resource, like models). The limit fields write nil
+    # when blank (off — the EdgeLimiter reads nil/0 as off); the windows fall back
+    # to the built-in defaults when cleared (the limiter guards non-positive).
+    def edge_patch(r)
+      edge = {}
+      %w[chat_rate_limit chat_rate_window agent_token_ceiling agent_token_window].each do |f|
+        edge[f] = edge_int(r.params[f], f)
+      end
+      edge["limit_response"] = presence(r.params["limit_response"])
+      { "edge" => edge }
+    end
+
+    # An eval case arrives as the YAML text the operator edited — the same shape the
+    # corpus files hold, so there is one format to learn and a pull request can review
+    # what was authored. Decoding happens HERE, at the transport edge; the SHAPE is
+    # validated by the one loader inside the store, so both doors agree.
+    def golden_patch(r)
+      parsed = begin
+        YAML.safe_load(r.params["yaml"].to_s, permitted_classes: [], aliases: false)
+      rescue Psych::SyntaxError => e
+        raise Insika::ValidationError, "invalid YAML: #{e.message}"
+      end
+      raise Insika::ValidationError, "the case must be a YAML mapping (id/agent/turns/expect)" unless parsed.is_a?(Hash)
+
+      { case: parsed }
+    end
+
+    # Evals graders. `judges` is one `provider/model` per LINE — a
+    # textarea, because the SIZE of the panel is the point and a fixed pair of fields
+    # would cap it at two. A bare `model` (no slash) is valid: the provider is then
+    # inferred by RubyLLM, same as everywhere else.
+    def evals_patch(r)
+      judges = r.params["judges"].to_s.lines.filter_map do |line|
+        ref = presence(line)
+        next unless ref
+
+        provider, model = ref.include?("/") ? ref.split("/", 2) : [nil, ref]
+        { "provider" => presence(provider), "model" => presence(model) }.compact
+      end.reject { |j| j["model"].nil? }
+
+      {
+        "evals" => {
+          "judges" => judges,
+          "aggregate" => %w[median mean min].include?(r.params["aggregate"]) ? r.params["aggregate"] : "median",
+          # Same strictness as the edge fields: a typo must not silently become "off"
+          # (min_agreement 0 would pass a case no judge liked).
+          "min_agreement" => edge_float(r.params["min_agreement"], "min_agreement"),
+          "quorum" => edge_int(r.params["quorum"], "quorum"),
+          "tolerance" => edge_float(r.params["tolerance"], "tolerance")
+        }.compact
+      }
+    end
+
+    # Strict float, blank = nil (inherit the default). Mirrors edge_int.
+    def edge_float(raw, field)
+      v = presence(raw)
+      return nil unless v
+
+      Float(v)
+    rescue ArgumentError, TypeError
+      raise Insika::ValidationError, "#{field} must be a number (got #{raw.inspect})"
+    end
+
+    # Strict integer for the edge fields: blank = nil (off / inherit — intentional),
+    # but an UNPARSEABLE value must not silently disable a production limit (the
+    # `coerce` drop-to-nil semantics would turn a typo into "off" with a green
+    # flash). ValidationError -> with_flash renders it as the red flash, no dispatch.
+    def edge_int(raw, field)
+      v = presence(raw)
+      return nil unless v
+
+      Integer(v)
+    rescue ArgumentError, TypeError
+      raise Insika::ValidationError, "#{field} must be an integer (got #{raw.inspect})"
+    end
+
+    # LLM config v2 — the platform model layer, saved from its OWN form (a
+    # sub-resource, like providers) so the general-settings save never touches it and
+    # vice-versa. The scalar refs are always present (blank -> nil, which the
+    # deep-merge writes and the ModelResolver reads as "no platform default");
+    # fallback_models is a full-list replace (deep_merge substitutes arrays, so a
+    # resubmit never accumulates).
+    def model_defaults_patch(r)
+      {
+        "default_model" => presence(r.params["default_model"]),
+        "default_provider" => presence(r.params["default_provider"]),
+        "utility_model" => presence(r.params["utility_model"]),
+        "fallback_models" => split_list(r.params["fallback_models"]),
+        # GLOBAL reasoning default (4-layer). Blank -> nil = provider default.
+        "thinking" => presence(r.params["thinking"])
+      }
+    end
+
+    # Per-model reasoning defaults (the per-model layer). One line per model:
+    #   <provider/model | model> | <off|on|low|medium|high>
+    # CSP forbids JS for dynamic rows, so a textarea of lines is the honest path
+    # (same idiom as the MCP env / tool params). A blank effort -> {} for that ref
+    # (an inherit no-op). deep_merge merges per-ref, so refs accumulate; clearing an
+    # override = set its effort blank (removing the ref entirely is a later refinement).
+    def model_params_patch(r)
+      map = r.params["model_params"].to_s.each_line.each_with_object({}) do |line, acc|
+        line = line.strip
+        next if line.empty? || line.start_with?("#")
+
+        ref, thinking = line.split("|", 2).map(&:strip)
+        next if ref.to_s.empty?
+
+        acc[ref] = { "thinking" => presence(thinking) }.compact
+      end
+      { "model_params" => map }
+    end
+
+    # LLM provider from the form. api_key is sentinel-aware: the form
+    # pre-fills with the sentinel when a key already exists, so resubmitting
+    # without touching preserves it; a new string replaces it; "" clears it. models = CSV.
+    def provider_patch(r)
+      {
+        api: presence(r.params["api"]),
+        base_url: r.params["base_url"].to_s,
+        auth_header: r.params["auth_header"].to_s,
+        api_key: r.params["api_key"].to_s,
+        models: split_list(r.params["models"])
+      }
+    end
+
+    # MCP instance from the form. `env` comes as "KEY=value" lines (CSP
+    # forbids inline JS for add/remove line; a textarea is the simple, honest
+    # path). Masked values come back as a sentinel — keeping them preserves
+    # the secret; changing replaces; deleting the line clears it.
+    def mcp_patch(r)
+      {
+        name: presence(r.params["name"]),
+        transport: presence(r.params["transport"]) || "stdio",
+        command: r.params["command"].to_s,
+        url: r.params["url"].to_s,
+        description: r.params["description"].to_s,
+        enabled: r.params["enabled"] == "1",
+        env: parse_kv_lines(r.params["env"])
+      }
+    end
+
+    # "KEY=value" per line -> Hash. Ignores blank lines and comments (#).
+    def parse_kv_lines(text)
+      text.to_s.each_line.filter_map do |line|
+        line = line.strip
+        next if line.empty? || line.start_with?("#")
+
+        k, v = line.split("=", 2)
+        k = k.to_s.strip
+        next if k.empty?
+
+        [k, v.to_s.strip]
+      end.to_h
+    end
+  end
+end

data/lib/insika/studio/nav_icons.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Studio
+  # Nav SVG icons for the Studio App. A mixin included into App: the
+  # `nav_icon` view helper and its icon table, moved verbatim out of app.rb.
+  # Inline SVG is CSP-safe (an HTML element, not an external resource).
+  module NavIcons
+    # 20×20 stroke icons (currentColor), one per nav key. Source: a Lucide-style
+    # line icon set.
+    NAV_ICONS = {
+      home: '<path d="M3 9.5 12 3l9 6.5"/><path d="M5 10v10a1 1 0 0 0 1 1h12a1 1 0 0 0 1-1V10"/><path d="M9 21v-6h6v6"/>',
+      agents: '<path d="M16 21v-2a4 4 0 0 0-4-4H6a4 4 0 0 0-4 4v2"/><circle cx="9" cy="7" r="4"/><path d="M22 21v-2a4 4 0 0 0-3-3.87"/><path d="M16 3.13a4 4 0 0 1 0 7.75"/>',
+      skills: '<path d="m12 3-1.9 5.8a2 2 0 0 1-1.3 1.3L3 12l5.8 1.9a2 2 0 0 1 1.3 1.3L12 21l1.9-5.8a2 2 0 0 1 1.3-1.3L21 12l-5.8-1.9a2 2 0 0 1-1.3-1.3z"/>',
+      tools: '<path d="M14.7 6.3a1 1 0 0 0 0 1.4l1.6 1.6a1 1 0 0 0 1.4 0l3.77-3.77a6 6 0 0 1-7.94 7.94l-6.91 6.91a2.12 2.12 0 0 1-3-3l6.91-6.91a6 6 0 0 1 7.94-7.94l-3.76 3.76z"/>',
+      system: '<path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z"/><path d="M14 2v6h6"/><path d="M8 13h8"/><path d="M8 17h8"/>',
+      mcp: '<rect x="3" y="3" width="7" height="7" rx="1"/><rect x="14" y="3" width="7" height="7" rx="1"/><rect x="14" y="14" width="7" height="7" rx="1"/><rect x="3" y="14" width="7" height="7" rx="1"/>',
+      settings: '<path d="M20 7h-9"/><path d="M14 17H5"/><circle cx="17" cy="17" r="3"/><circle cx="7" cy="7" r="3"/>',
+      chats: '<path d="M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z"/>',
+      playground: '<polygon points="6 3 20 12 6 21 6 3"/>',
+      tasks: '<path d="M11 12H3"/><path d="M16 6H3"/><path d="M16 18H3"/><path d="m18 9 3 3-3 3"/>',
+      approvals: '<path d="M9 12l2 2 4-4"/><path d="M12 3a9 9 0 1 0 9 9"/>',
+      refinement: '<path d="M21 12a9 9 0 1 1-3-6.7"/><path d="M21 3v5h-5"/><path d="m9 12 2 2 4-4"/>',
+      evals: '<path d="M9 11l3 3L22 4"/><path d="M21 12v7a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h11"/>'
+    }.freeze
+
+    def nav_icon(key)
+      %(<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.7" ) +
+        %(stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">#{NAV_ICONS[key]}</svg>)
+    end
+  end
+end

data/lib/insika/studio/views/_message.erb

@@ -0,0 +1,44 @@
+<%# Shared transcript bubble/tool-card — one visual language for the
+    playground history, the optimistic echo and the read-only session viewer.
+    Locals: m = stored message hash {"role","content","at"}; prev = the message before
+    it in the thread, or nil (used only to spot a steered message). `content` may be a
+    String or a structured payload (rendered as pretty JSON, never #inspect).
+    Assistant bubbles carry data-controller="markdown" (markdown.js re-escapes
+    before markup — safe under the strict CSP). %>
+<% role = m["role"].to_s %>
+<% at = short_time(m["at"]) %>
+<% if role == "tool" %>
+  <details class="toolcard result">
+    <summary><span class="arrow">←</span><strong>tool result</strong><% unless at.empty? %><time class="stamp" datetime="<%= m["at"] %>"><%= at %></time><% end %></summary>
+    <pre><%= message_content(m["content"]) %></pre>
+  </details>
+<% else %>
+  <div class="msg <%= role %>">
+    <div class="who"><%= role[0, 1].upcase %></div>
+    <div class="bubble">
+      <%# `role` says where a message sits; `origin` says who wrote it, and the two
+          come apart (the engine delivering a subagent result as a "user" turn, a
+          guardrail's canned reply, a human operator after a handoff). Shown only
+          when it is NOT the natural producer for the role — otherwise every bubble
+          would carry a label that says nothing. %>
+      <% origin = Insika::MessageOrigin.origin_of(m) unless Insika::MessageOrigin.customer?(m) || Insika::MessageOrigin.agent?(m) %>
+      <%# STEERED: a customer message sitting right after a tool result arrived
+          while the turn was running and was appended at a tool-batch boundary. Derived
+          from position, not from a field — a steered message declares no origin, and it
+          is right not to: a person typed it. Nothing else in the engine ever puts a user
+          message after a tool result. Without the marker an operator reads two customer
+          messages in one turn with no explanation. %>
+      <% steered = role == "user" && prev && prev["role"].to_s == "tool" %>
+      <div class="role-tag"><%= role %><% if origin %> · <span class="origin"><%= origin %></span><% end %><% if steered %> · <span class="origin">steered</span><% end %><% unless at.empty? %> · <time class="stamp" datetime="<%= m["at"] %>"><%= at %></time><% end %></div>
+      <% unless m["content"].to_s.empty? && Array(m["tool_calls"]).any? %>
+        <div class="content<%== ' md' if role == 'assistant' %>"<%== ' data-controller="markdown"' if role == 'assistant' %>><%= message_content(m["content"]) %></div>
+      <% end %>
+      <% Array(m["tool_calls"]).each do |tc| %>
+        <details class="toolcard">
+          <summary><span class="arrow">→</span><strong><%= tc["name"] %></strong></summary>
+          <pre><%= message_content(tc["arguments"]) %></pre>
+        </details>
+      <% end %>
+    </div>
+  </div>
+<% end %>