tina4ruby 3.13.146 → 3.13.148

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aaafd9078b79dd56e7829b0a92ee162c3eaf471c7102746ed1b119f523f42b8e
-  data.tar.gz: eaa7f47dd692a137d5fce2395696a3f84addfb1feaf8a74b96f936f4177ffcf4
+  metadata.gz: 5f81aa317ab408c5f85fa182149d2bddf74f76a6dbe0d07eab1346335f2feb18
+  data.tar.gz: a877a9d71c42570d719c721427d164581919c15e235e17d366891a5337a7920c
 SHA512:
-  metadata.gz: 2b50b1109f4b5caf4001fde5141a248c5eaf7d6b9fb691eebe267235f2b7ad2f513b771eefa7233b4b6ef849908aad2e5671b04adee72cdbb674702ba9b2f1a1
-  data.tar.gz: dbc2ffdc2dd55b7ca03b8de790fc24793edf4ff58de61eeec66196444c8bd8788596cc9c518cecf83c1e8021e8710592f3a947e1039a15da2c5f8305c3e955ea
+  metadata.gz: 4da03de83c10544ac690ce24d6b951b6ba688fab57fb01cb4cf5a630d1e1d41dd5fbab7397538a2910708409c3fb6fea74285ce84fd74559fb883d83303b66d6
+  data.tar.gz: cb21b614d729b774a1d9ec16ada8674cab6663e675a370ed7cb8b3f588b3c038036ba0d43bedcf764f1ab673b117df005e30063d50612ce8ace479300104d127

data/CHANGELOG.md

@@ -6,6 +6,23 @@ number means the same thing everywhere.
 **The authoritative release notes for every shipped version live in the documentation:**
 https://tina4.com/ruby/36-releases
 
+## 3.13.148 — 2026-10-05
+
+### Session
+- An anonymous request stores no session — a request that never reads or writes session state no longer emits a `Set-Cookie` or persists an empty session record (cross-framework fix, at parity across Python, PHP, Ruby, Node.js).
+
+### AI skills
+- `tina4-developer-ruby` skill `updated_for_version` bumped to this release.
+
+## 3.13.147 — 2026-10-05
+
+### Dev MCP tools (fixes #271)
+- `database_columns` reads schema metadata so an empty table returns its columns; a missing table returns a clear `table not found` error.
+- Tool argument validation returns an actionable `missing/unknown argument` error instead of a raw Ruby error; `api_method` now populates `params` and `return`.
+- `route_list` entries include each route's `middleware`.
+- A new route file added at runtime surfaces a signal.
+- Developer skill corrected: per-language hot-reload reality, and `api_method` shown with argument names.
+
 ## 3.13.146 — 2026-10-04
 
 ### AI skills

data/lib/tina4/dispatch_pipeline.rb

@@ -649,12 +649,11 @@ module Tina4
       # renamed through TINA4_SESSION_NAME, so the auto-Set-Cookie would be
       # needlessly re-emitted on every request that already carries the renamed
       # cookie. Parity with Python's core/server._init_session cookie_prefix.
-      sid = sess.id
       cookie_prefix = "#{Tina4::Session.cookie_name}="
       cookie_val = (ctx.env["HTTP_COOKIE"] || "").split(";").map(&:strip)
                                                  .find { |part| part.start_with?(cookie_prefix) }
                                                  &.slice(cookie_prefix.length..)
-      if sid && sid != cookie_val
+      if session_needs_cookie?(sess, cookie_val)
         # Route through Session#cookie_header rather than hand-writing the
         # header, so TINA4_SESSION_SECURE / _SAMESITE / _HTTPONLY / _NAME / _TTL
         # are all honoured and Secure reflects the request scheme. The old
@@ -666,6 +665,19 @@ module Tina4
       [status, headers, body_parts]
     end
 
+    # Whether the response must carry a session cookie: the session has an id the
+    # request did not already send, and it is not a fresh one. A fresh session
+    # (minted for this request and never written: a route that only read it, or
+    # the replacement for a cookie the store does not know) was not stored, so a
+    # cookie for it would name nothing - the next request could not resume it and
+    # would be handed another one.
+    def session_needs_cookie?(sess, cookie_val)
+      sid = sess.id
+      return false unless sid && sid != cookie_val
+
+      !(sess.respond_to?(:fresh?) && sess.fresh?)
+    end
+
     # Milliseconds since the request entered the pipeline.
     def elapsed_ms(ctx)
       ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - ctx.started_at) * 1000).round(3)

data/lib/tina4/docs.rb

@@ -432,6 +432,7 @@ module Tina4
           private_flag = visibility != "public" || underscored
 
           summary, doc = split_doc(pending_doc)
+          returns = pending_doc.join(" ")[/@return\s+\[([^\]]+)\]/, 1].to_s
           method_fqn = if is_static
             "#{current_class[:fqn]}.#{mname}"
           else
@@ -446,6 +447,7 @@ module Tina4
             class_fqn:   current_class[:fqn],
             class:       current_class[:fqn],
             signature:   signature,
+            returns:     returns,
             summary:     summary,
             docstring:   doc,
             file:        rel_file,
@@ -620,11 +622,54 @@ module Tina4
         static:     entry[:static] || false,
         source:     entry[:source],
         version:    entry[:version],
-        params:     [],
-        return:     "",
+        params:     params_from_signature(entry[:signature]),
+        return:     entry[:returns].to_s,
       }
     end
 
+    # Structured params parsed from a Ruby signature such as
+    # "fetch(sql, params = [], limit: 100, **opts)" -- same shape Python
+    # reports: [{name, type, required, default}]. Ruby has no inline type
+    # annotations, so type is "" unless the docblock says otherwise.
+    def params_from_signature(signature)
+      inner = signature.to_s[/\A[^(]*\((.*)\)\z/m, 1]
+      return [] if inner.nil? || inner.strip.empty?
+
+      split_top_level_commas(inner).map { |piece| param_entry(piece.strip) }
+    end
+
+    def param_entry(piece)
+      prefix = piece[/\A(\*\*|\*|&)/, 1]
+      return { name: piece, type: "", required: false, default: nil } if prefix
+
+      keyword = piece.match(/\A([A-Za-z_]\w*):\s*(.*)\z/m)
+      if keyword
+        default = keyword[2].strip
+        return { name: keyword[1], type: "", required: default.empty?, default: default.empty? ? nil : default }
+      end
+
+      name, default = piece.split(/\s*=\s*/, 2)
+      { name: name.strip, type: "", required: default.nil?, default: default&.strip }
+    end
+
+    def split_top_level_commas(text)
+      pieces = []
+      depth = 0
+      current = +""
+      text.each_char do |ch|
+        depth += 1 if "([{".include?(ch)
+        depth -= 1 if ")]}".include?(ch)
+        if ch == "," && depth.zero?
+          pieces << current
+          current = +""
+        else
+          current << ch
+        end
+      end
+      pieces << current unless current.strip.empty?
+      pieces
+    end
+
     # ── Sync writer ──────────────────────────────────────────────────
 
     def render_generated_block

data/lib/tina4/mcp.rb

@@ -139,6 +139,17 @@ module Tina4
     schema
   end
 
+  # Readable name for one attached route middleware (class, instance, string
+  # spec or lambda) -- what route_list reports under "middleware".
+  def self.middleware_label(attached)
+    case attached
+    when ::String then attached
+    when ::Module then attached.name || attached.inspect
+    when ::Proc, ::Method then "proc"
+    else attached.class.name || attached.inspect
+    end
+  end
+
   # Informational only — whether the CONFIGURED host looks local.
   #
   # NOT the security gate. This reads TINA4_HOST_NAME (the configured bind
@@ -510,22 +521,47 @@ module Tina4
       raise ArgumentError, "Unknown tool: #{tool_name}" if tool.nil?
 
       arguments = params.fetch("arguments", {})
+      arguments = {} if arguments.nil?
       handler   = tool["handler"]
 
+      # Validate against the tool's input schema BEFORE invoking, so a missing
+      # or unknown argument is an actionable message, never a raw Ruby
+      # ArgumentError. Python parity (tina4_python.mcp).
+      argument_error = validate_tool_arguments(tool_name, tool["inputSchema"], arguments)
+      return mcp_text_content(argument_error) if argument_error
+
       # Call the handler -- support both keyword and positional args
       result = _invoke_handler(handler, arguments)
 
-      # Format result as MCP content
-      content = case result
-                when String
-                  [{ "type" => "text", "text" => result }]
-                when Hash, Array
-                  [{ "type" => "text", "text" => JSON.pretty_generate(result) }]
-                else
-                  [{ "type" => "text", "text" => result.to_s }]
-                end
+      mcp_text_content(result)
+    end
+
+    # Format a tool result as MCP content.
+    def mcp_text_content(result)
+      text = case result
+             when String then result
+             when Hash, Array then JSON.pretty_generate(result)
+             else result.to_s
+             end
+      { "content" => [{ "type" => "text", "text" => text }] }
+    end
+
+    # Returns nil when the arguments satisfy the schema, else an
+    # { "error" => "missing required argument 'p' (tool takes p1, p2)" } hash
+    # (or "unknown argument ..." with the same shape).
+    def validate_tool_arguments(tool_name, schema, arguments)
+      return { "error" => "arguments for #{tool_name} must be an object" } unless arguments.is_a?(Hash)
 
-      { "content" => content }
+      properties = (schema || {}).fetch("properties", {}).keys
+      takes = "(#{tool_name} takes #{properties.join(', ')})"
+
+      missing = (schema || {}).fetch("required", []).find { |name| !arguments.key?(name) }
+      return { "error" => "missing required argument '#{missing}' #{takes}" } if missing
+
+      unknown = arguments.keys.map(&:to_s).find { |name| !properties.include?(name) }
+      return { "error" => "unknown argument '#{unknown}' #{takes}" } if unknown
+
+      nil
     end
 
     def _handle_resources_list(_params)
@@ -888,7 +924,13 @@ module Tina4
         unless table.to_s =~ /\A[A-Za-z_][A-Za-z0-9_$]*(\.[A-Za-z_][A-Za-z0-9_$]*)?\z/
           return { "error" => "Invalid table name" }
         end
-        db.columns(table)
+        # Schema metadata (PRAGMA / information_schema), never the first row, so
+        # an EMPTY table still reports its columns. A table that does not exist
+        # has no columns: say so rather than answering [].
+        columns = db.columns(table)
+        next { "error" => "table not found: #{table}" } if columns.nil? || columns.empty?
+
+        columns
       }, "Get column definitions for a table")
 
       # ── Route Tools ───────────────────────────────────
@@ -899,7 +941,8 @@ module Tina4
           {
             "method"        => route.method.to_s,
             "path"          => route.path.to_s,
-            "auth_required" => route.auth_required ? true : false
+            "auth_required" => route.auth_required ? true : false,
+            "middleware"    => route.middleware.map { |attached| Tina4.middleware_label(attached) }
           }
         end
       }, "List all registered routes")
@@ -1458,9 +1501,14 @@ module Tina4
         Tina4::Docs.cached(project_root).class_spec(name.to_s)
       }, "Full class reflection (methods, file, line) from the live API index")
 
-      server.register_tool("api_method", lambda { |class_name:, name:|
-        Tina4::Docs.cached(project_root).method_spec(class_name.to_s, name.to_s)
-      }, "Single method spec (signature, summary, file, line) from the live API index")
+      server.register_tool("api_method", lambda { |name:, **rest|
+        class_name = rest[:class].to_s
+        Tina4::Docs.cached(project_root).method_spec(class_name, name.to_s) ||
+          { "error" => "method not found: #{class_name}.#{name}" }
+      }, "Single method spec (signature, params, return, file, line) from the live API index",
+         { "type" => "object",
+           "properties" => { "class" => { "type" => "string" }, "name" => { "type" => "string" } },
+           "required" => %w[class name] })
 
       # ── Code/doc grounding (semantic FTS over this repo's source) ──
       # code_search is the fuzzy DUAL of the structural api_* tools:

data/lib/tina4/session.rb

@@ -217,7 +217,7 @@ module Tina4
     # false) therefore still no-ops, exactly as before; a modified session of
     # any kind still writes.
     def save
-      return true unless @id && (@modified || @stored)
+      return true if @id.nil? || fresh?
 
       record = @data
       if @stored
@@ -247,6 +247,17 @@ module Tina4
       end
     end
 
+    # Whether this session is only an id: nothing has stored it and it holds no
+    # data. Such a session has no record and needs no cookie, so #save writes
+    # nothing for it and the dispatcher sends no cookie for it. It stops being
+    # fresh when something is stored in it. Calls that mark a session changed
+    # without leaving anything in it (deleting a key it never had, #clear,
+    # #regenerate on an empty session) leave it fresh: a record with no data is
+    # not a session.
+    def fresh?
+      !@stored && @data.empty?
+    end
+
     # Destroy the current session. ENDS the session: the stored record is
     # removed and the id is CLEARED (@id = nil), so a later set()+save() with no
     # new #start has no id to persist under and cannot RESURRECT the just-

data/lib/tina4/version.rb

@@ -7,5 +7,5 @@
 
 
 module Tina4
-  VERSION = "3.13.146"
+  VERSION = "3.13.148"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tina4ruby
 version: !ruby/object:Gem::Version
-  version: 3.13.146
+  version: 3.13.148
 platform: ruby
 authors:
 - Tina4 Team
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-04 00:00:00.000000000 Z
+date: 2026-10-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sqlite3