tina4ruby 3.11.18 → 3.11.32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2aa9ce02d7a7c924ae48d78b5ed1485261b85cde643ab13501040ea5bc7145da
-  data.tar.gz: f97407bec1e490e48714ae6d00ee78ad211b74e50ec0f94325d92f3dbf935e43
+  metadata.gz: b1d2fabb4883ebcdd387f24cfc0c3e858304d7498b1439798b448c89623fa56e
+  data.tar.gz: 592c8eac568eba0950bde87ac4fd9b7d9bfed365aa23539b2f50409ff6a1f1d9
 SHA512:
-  metadata.gz: c2bfb361e4de75738221dbdfb8f7a070cf224b71d02c389b0bc62171dd6566dea13d8fb0677f119ef331295d234fb1269d4a5a6573d026302d1c9d6c1b75a8e4
-  data.tar.gz: ac914458d86220ae3788f9a7da1a3cd427d4b0901139b53f57e007f93103bb5d82ded233b449dcebad4ae8145624ca971e9d056d36ae103f808b66c5a67689b3
+  metadata.gz: '0917b8cbeaaa155cbf223bcb009662bed7f48e03e1b9b4d96c338a17fdf2cbac4333d88c549980d650a70eb515532b83783090cb4f3896ca8f7f53fba8307347'
+  data.tar.gz: c9b3da407eb7823e9e7b19af1d3928329d061b5a8d77bd904d96870ea89e90d9dbd0979b3909bff66011c584e556bb2c3dfcf219a078e6ffd28d2ac75cea9a7e

data/lib/tina4/database.rb

@@ -109,6 +109,15 @@ module Tina4
       @pool_size = pool  # 0 = single connection, N>0 = N pooled connections
       @connected = false
 
+      # Per-instance thread-local key for the transaction adapter pin.
+      # Without this pin, every Database method call rotates to a different
+      # pooled connection. Inside a transaction this silently breaks atomicity:
+      # start_transaction begins on adapter A, executes autocommit on B/C, and
+      # commit/rollback land on D — a no-op. start_transaction sets the pin,
+      # commit/rollback clear it. While pinned, current_driver returns the same
+      # driver for every call so the whole transaction runs on one connection.
+      @tx_pin_key = :"tina4_pinned_adapter_#{object_id}"
+
       # Query cache — off by default, opt-in via TINA4_DB_CACHE=true
       @cache_enabled = truthy?(ENV["TINA4_DB_CACHE"])
       @cache_ttl = (ENV["TINA4_DB_CACHE_TTL"] || "30").to_i
@@ -161,7 +170,14 @@ module Tina4
     end
 
     # Get the current driver — from pool (round-robin) or single connection.
+    #
+    # Inside a transaction, all calls must land on the SAME driver — otherwise
+    # start_transaction, execute, and commit each rotate to a different pooled
+    # connection and the transaction is meaningless. start_transaction pins
+    # the driver to the calling thread; commit/rollback release it.
     def current_driver
+      pinned = Thread.current[@tx_pin_key]
+      return pinned if pinned
       if @pool
         @pool.checkout
       else
@@ -355,27 +371,38 @@ module Tina4
 
     def transaction
       drv = current_driver
+      Thread.current[@tx_pin_key] = drv
       drv.begin_transaction
       yield self
       drv.commit
     rescue => e
-      drv.rollback
+      drv.rollback if drv
       raise e
+    ensure
+      Thread.current[@tx_pin_key] = nil
     end
 
     # Begin a transaction without a block — matches PHP/Python/Node API.
+    # Pins the driver to this thread for the whole transaction so executes
+    # and the final commit/rollback all run on the same connection.
     def start_transaction
-      current_driver.begin_transaction
+      drv = current_driver
+      Thread.current[@tx_pin_key] = drv
+      drv.begin_transaction
     end
 
-    # Commit the current transaction — matches PHP/Python/Node API.
+    # Commit the current transaction and release the driver pin.
     def commit
       current_driver.commit
+    ensure
+      Thread.current[@tx_pin_key] = nil
     end
 
-    # Roll back the current transaction — matches PHP/Python/Node API.
+    # Roll back the current transaction and release the driver pin.
     def rollback
       current_driver.rollback
+    ensure
+      Thread.current[@tx_pin_key] = nil
     end
 
     def tables

data/lib/tina4/dev_admin.rb

@@ -316,9 +316,55 @@ module Tina4
         Tina4::Env.is_truthy(ENV["TINA4_DEBUG"])
       end
 
+      # Write `.tina4/mcp.json` so MCP-aware tools (Claude Code, Cursor) can
+      # auto-discover this project's live docs server. Idempotent — no-op if
+      # the file already matches the desired contents. Also appends `.tina4/`
+      # to the project's `.gitignore` if a git repo is present.
+      def auto_discover_mcp!(project_root: Dir.pwd)
+        return if @_mcp_auto_discovered
+        @_mcp_auto_discovered = true
+        return unless enabled?
+
+        port = ENV["TINA4_PORT"] || ENV["PORT"] || "7147"
+        url  = "http://localhost:#{port}/__dev/api/mcp"
+        target_dir = File.join(project_root, ".tina4")
+        target = File.join(target_dir, "mcp.json")
+        payload = {
+          "mcpServers" => {
+            "tina4-live-docs" => {
+              "url" => url,
+              "description" => "Live API docs for this Tina4 project (framework + user code)",
+            },
+          },
+        }
+        begin
+          FileUtils.mkdir_p(target_dir)
+          existing = if File.file?(target)
+                       (JSON.parse(File.read(target)) rescue {})
+                     else
+                       {}
+                     end
+          if existing != payload
+            File.write(target, JSON.pretty_generate(payload))
+          end
+
+          gitignore = File.join(project_root, ".gitignore")
+          if File.directory?(File.join(project_root, ".git"))
+            current = File.file?(gitignore) ? File.read(gitignore) : ""
+            unless current.lines.map(&:strip).include?(".tina4/") || current.lines.map(&:strip).include?(".tina4")
+              prefix = (!current.empty? && !current.end_with?("\n")) ? "\n" : ""
+              File.write(gitignore, "#{current}#{prefix}.tina4/\n")
+            end
+          end
+        rescue StandardError => e
+          Tina4::Log.warning("auto_discover_mcp! failed: #{e.message}") if defined?(Tina4::Log)
+        end
+      end
+
       # Handle a /__dev request; returns [status, headers, body] or nil if not a dev path
       def handle_request(env)
         return nil unless enabled?
+        auto_discover_mcp!
 
         path = env["PATH_INFO"] || "/"
         method = env["REQUEST_METHOD"]
@@ -548,6 +594,16 @@ module Tina4
         when ["POST", "/__dev/api/scaffold/run"]
           body = read_json_body(env) || {}
           json_response(scaffold_run(body))
+        when ["GET", "/__dev/api/docs/search"]
+          json_response(docs_search_payload(env))
+        when ["GET", "/__dev/api/docs/class"]
+          json_response(docs_class_payload(query_param(env, "name")))
+        when ["GET", "/__dev/api/docs/method"]
+          json_response(docs_method_payload(query_param(env, "class"), query_param(env, "name")))
+        when ["GET", "/__dev/api/docs/index"]
+          json_response(docs_index_payload(query_param(env, "source")))
+        when ["GET", "/__dev/api/docs/.well-known.json"]
+          json_response(docs_well_known_payload)
         when ["GET", "/__dev/api/graphql/schema"]
           begin
             gql = Tina4::GraphQL.new
@@ -1286,6 +1342,56 @@ module Tina4
           { ok: false, error: "unknown kind: #{kind}" }
         end
       end
+
+      # ── Live Docs (Live API RAG) ─────────────────────────────────
+
+      def docs_search_payload(env)
+        q = (query_param(env, "q") || "").to_s
+        k = (query_param(env, "k") || "5").to_i
+        source = (query_param(env, "source") || "all").to_s
+        include_private = %w[1 true yes].include?((query_param(env, "include_private") || "").to_s.downcase)
+        started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        results = Tina4::Docs.cached(Dir.pwd).search(
+          q, k: k, source: source, include_private: include_private
+        )
+        took_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - started) * 1000.0).round(2)
+        { ok: true, query: q, results: results, took_ms: took_ms }
+      end
+
+      def docs_class_payload(name)
+        spec = Tina4::Docs.cached(Dir.pwd).class_spec(name.to_s)
+        return { ok: false, error: "class not found: #{name}" } if spec.nil?
+        { ok: true, class: spec }
+      end
+
+      def docs_method_payload(class_fqn, name)
+        spec = Tina4::Docs.cached(Dir.pwd).method_spec(class_fqn.to_s, name.to_s)
+        return { ok: false, error: "method not found: #{class_fqn}##{name}" } if spec.nil?
+        { ok: true, method: spec }
+      end
+
+      def docs_index_payload(source)
+        idx = Tina4::Docs.cached(Dir.pwd).index
+        idx = idx.select { |e| e[:source] == source } if source && %w[framework user vendor].include?(source.to_s)
+        { ok: true, count: idx.size, entries: idx }
+      end
+
+      def docs_well_known_payload
+        {
+          ok: true,
+          service: "tina4-live-docs",
+          version: Tina4::VERSION,
+          framework: "tina4-ruby",
+          endpoints: {
+            search: "/__dev/api/docs/search?q=<query>&k=<int>&source=<framework|user|all>&include_private=<bool>",
+            class:  "/__dev/api/docs/class?name=<fqn>",
+            method: "/__dev/api/docs/method?class=<fqn>&name=<method>",
+            index:  "/__dev/api/docs/index?source=<framework|user|all>",
+          },
+          mcp: { url: "/__dev/api/mcp", tools: %w[api_search api_class api_method] },
+          spec: "https://tina4.com — Live API RAG plan/v3/22-LIVE-API-RAG.md",
+        }
+      end
     end
   end
 end