tina4ruby 3.11.32 → 3.11.35

data/lib/tina4/drivers/firebird_driver.rb

@@ -5,6 +5,20 @@ module Tina4
     class FirebirdDriver
       attr_reader :connection
 
+      # Substring markers (lowercased) that identify a dead-socket Firebird
+      # error worth reconnecting for. Idle Firebird connections die silently
+      # behind NAT timeouts, server-side ConnectionIdleTimeout, or Docker
+      # network rotation; without this the next prepare crashes the request.
+      DEAD_CONN_MARKERS = [
+        "error writing data to the connection",
+        "error reading data from the connection",
+        "connection shutdown",
+        "connection lost",
+        "network error",
+        "connection is not active",
+        "broken pipe"
+      ].freeze
+
       def connect(connection_string, username: nil, password: nil)
         require "fb"
         require "uri"
@@ -21,10 +35,13 @@ module Tina4
                      db_path || connection_string.sub(/^firebird:\/\//, "")
                    end
 
-        opts = { database: database }
-        opts[:username] = db_user if db_user
-        opts[:password] = db_pass if db_pass
-        @connection = Fb::Database.new(**opts).connect
+        # Cache for transparent reconnect — never logged, lives only in
+        # driver memory alongside the connection it owns.
+        @connect_opts = { database: database }
+        @connect_opts[:username] = db_user if db_user
+        @connect_opts[:password] = db_pass if db_pass
+
+        open_connection
       rescue LoadError
         raise "Firebird driver requires the 'fb' gem. Install it with: gem install fb"
       end
@@ -34,22 +51,35 @@ module Tina4
       end
 
       def execute_query(sql, params = [])
-        rows = if params.empty?
-                 @connection.query(:hash, sql)
-               else
-                 @connection.query(:hash, sql, *params)
-               end
+        rows = with_reconnect do
+          if params.empty?
+            @connection.query(:hash, sql)
+          else
+            @connection.query(:hash, sql, *params)
+          end
+        end
         rows.map { |row| decode_blobs(stringify_keys(row)) }
       end
 
       def execute(sql, params = [])
-        if params.empty?
-          @connection.execute(sql)
-        else
-          @connection.execute(sql, *params)
+        with_reconnect do
+          if params.empty?
+            @connection.execute(sql)
+          else
+            @connection.execute(sql, *params)
+          end
         end
       end
 
+      # Public so specs (and curious operators) can verify the matcher
+      # behaviour without poking private methods.
+      def self.dead_connection?(error_or_message)
+        msg = error_or_message.respond_to?(:message) ? error_or_message.message : error_or_message.to_s
+        return false if msg.nil? || msg.empty?
+        lower = msg.downcase
+        DEAD_CONN_MARKERS.any? { |m| lower.include?(m) }
+      end
+
       def last_insert_id
         nil
       end
@@ -103,6 +133,34 @@ module Tina4
 
       private
 
+      def open_connection
+        @connection = Fb::Database.new(**@connect_opts).connect
+      end
+
+      # Force-close a stale handle and reopen using cached opts. Idempotent —
+      # safe to call when the connection is already gone.
+      def reconnect!
+        begin
+          @connection&.close
+        rescue StandardError
+          # connection already gone — nothing to clean up
+        end
+        @connection = nil
+        @transaction = nil
+        open_connection
+      end
+
+      # Run a block; if it raises with a dead-connection signature, reconnect
+      # once and retry. Skipped inside an explicit transaction — atomicity
+      # beats resilience there; the caller handles rollback.
+      def with_reconnect
+        yield
+      rescue StandardError => e
+        raise unless self.class.dead_connection?(e) && @transaction.nil?
+        reconnect!
+        yield
+      end
+
       def stringify_keys(hash)
         hash.each_with_object({}) { |(k, v), h| h[k.to_s] = v }
       end

data/lib/tina4/frond.rb

@@ -548,20 +548,6 @@ module Tina4
       value = eval_expr(var_name, context)
       filters.each do |fname, args|
         next if fname == "raw" || fname == "safe"
-
-        # Filter + property-access chain: `first.groupSummary` — apply
-        # the filter, then traverse the path on the result using a
-        # synthetic context so eval_expr's dotted resolution does the
-        # work. Parity with tina4-python + tina4-php.
-        real_fname, tail_path = split_filter_name_and_path(fname)
-        if !tail_path.empty? && @filters[real_fname]
-          evaluated_args = args.map { |a| eval_filter_arg(a, context) }
-          value = @filters[real_fname].call(value, *evaluated_args)
-          value = eval_expr("__frond_filter_tmp.#{tail_path}",
-                            { "__frond_filter_tmp" => value })
-          next
-        end
-
         fn = @filters[fname]
         if fn
           evaluated_args = args.map { |a| eval_filter_arg(a, context) }
@@ -625,19 +611,6 @@ module Tina4
           next
         end
 
-        # Filter + property-access chain: `first.groupSummary` — apply
-        # the filter, then traverse the path on the result. Done BEFORE
-        # the inline fast-path so cases like `items|first.name` work
-        # regardless of whether `first` is an inline filter too.
-        real_fname, tail_path = split_filter_name_and_path(fname)
-        if !tail_path.empty? && @filters[real_fname]
-          evaluated_args = args.map { |a| eval_filter_arg(a, context) }
-          value = @filters[real_fname].call(value, *evaluated_args)
-          value = eval_expr("__frond_filter_tmp.#{tail_path}",
-                            { "__frond_filter_tmp" => value })
-          next
-        end
-
         # Inline common no-arg filters for speed (skip generic dispatch)
         if args.empty? && INLINE_FILTERS.include?(fname)
           value = case fname
@@ -783,41 +756,6 @@ module Tina4
     # Filter chain parser
     # -----------------------------------------------------------------------
 
-    # Split "first.groupSummary" into ["first", "groupSummary"] so a
-    # filter segment followed by property access — `{{ x | first.name }}`
-    # — applies the filter then traverses the path on the result.
-    # Returns [fname, ""] when no structural dot is present.
-    #
-    # The split point must sit outside parens/brackets/braces and quotes
-    # so filter args like `round(1.5)` or `date("Y.m.d")` don't false-
-    # trigger. Parity with tina4-python and tina4-php.
-    def split_filter_name_and_path(fname)
-      depth = 0
-      in_q  = nil
-      i     = 0
-      n     = fname.length
-      while i < n
-        ch = fname[i]
-        if in_q
-          in_q = nil if ch == in_q && (i.zero? || fname[i - 1] != "\\")
-          i += 1
-          next
-        end
-        case ch
-        when '"', "'"
-          in_q = ch
-        when "(", "[", "{"
-          depth += 1
-        when ")", "]", "}"
-          depth -= 1
-        when "."
-          return [fname[0...i], fname[(i + 1)..]] if depth.zero?
-        end
-        i += 1
-      end
-      [fname, ""]
-    end
-
     def parse_filter_chain(expr)
       cached = @filter_chain_cache[expr]
       return cached if cached

data/lib/tina4/mcp.rb

@@ -680,196 +680,6 @@ module Tina4
         end
       }, "Seed a table with fake data")
 
-      # ── File patch ────────────────────────────────────
-      server.register_tool("file_patch", lambda { |path:, old_string:, new_string:, count: 1|
-        p = safe_path.call(path)
-        return { "error" => "File not found: #{path}" } unless File.file?(p)
-        original = File.read(p, encoding: "utf-8")
-        occurrences = original.scan(old_string).size
-        return { "error" => "old_string not found in #{path}" } if occurrences.zero?
-        if occurrences != count.to_i
-          return { "error" => "old_string appears #{occurrences} times, expected #{count}. Expand old_string to make it unique, or set count explicitly." }
-        end
-        updated = original.sub(old_string, new_string)
-        # Ruby String#sub replaces first; if count > 1, do N replacements
-        if count.to_i > 1
-          updated = original.dup
-          count.to_i.times { updated.sub!(old_string, new_string) }
-        end
-        File.write(p, updated, encoding: "utf-8")
-        rel = p.sub("#{project_root}/", "")
-        Tina4::Plan.record_action("patched", rel) if defined?(Tina4::Plan)
-        { "patched" => rel, "replacements" => count.to_i, "bytes" => updated.bytesize }
-      }, "Targeted edit: replace old_string with new_string in a file")
-
-      # ── Docs tools ────────────────────────────────────
-      framework_doc_paths = lambda do
-        gem_root = File.expand_path("..", File.dirname(__FILE__))
-        candidates = [
-          File.join(gem_root, "..", "CLAUDE.md"),
-          File.join(gem_root, "..", "AGENTS.md"),
-          File.join(gem_root, "..", "CONVENTIONS.md"),
-          File.join(gem_root, "..", "README.md"),
-          File.join(Dir.pwd, "CLAUDE.md")
-        ]
-        candidates.map { |p| File.expand_path(p) }.uniq.select { |p| File.file?(p) }
-      end
-
-      server.register_tool("docs_list", lambda {
-        framework_doc_paths.call.map { |p| { "name" => File.basename(p), "bytes" => File.size(p) } }
-      }, "List framework documentation files")
-
-      server.register_tool("docs_search", lambda { |query:, limit: 5, context_lines: 4|
-        return { "error" => "query must be at least 2 characters" } if query.to_s.length < 2
-        needle = query.to_s.downcase
-        hits = []
-        framework_doc_paths.call.each do |p|
-          begin
-            lines = File.read(p, encoding: "utf-8", invalid: :replace, undef: :replace).split("\n")
-          rescue StandardError
-            next
-          end
-          lines.each_with_index do |line, i|
-            next unless line.downcase.include?(needle)
-            start_i = [0, i - context_lines.to_i].max
-            end_i   = [lines.size, i + context_lines.to_i + 1].min
-            score = 1
-            score += 1 if line.include?(query.to_s)
-            score += 2 if line.lstrip.start_with?("#")
-            hits << {
-              "file" => File.basename(p),
-              "line" => i + 1,
-              "score" => score,
-              "snippet" => lines[start_i...end_i].join("\n")
-            }
-          end
-        end
-        hits.sort_by! { |h| -h["score"] }
-        hits.first([1, limit.to_i].max)
-      }, "Search Tina4 framework docs for a query string")
-
-      server.register_tool("docs_section", lambda { |file:, heading:|
-        match = framework_doc_paths.call.find { |p| File.basename(p) == file }
-        return { "error" => "Unknown doc file: #{file}. Try docs_list() first." } unless match
-        text = File.read(match, encoding: "utf-8", invalid: :replace, undef: :replace)
-        lines = text.split("\n")
-        heading_lc = heading.to_s.downcase.strip
-        start_i = -1
-        start_level = 0
-        lines.each_with_index do |line, i|
-          stripped = line.lstrip
-          next unless stripped.start_with?("#")
-          level = stripped.length - stripped.sub(/\A#+/, "").length
-          title = stripped[level..].to_s.strip.downcase
-          if title.include?(heading_lc)
-            start_i = i
-            start_level = level
-            break
-          end
-        end
-        return { "error" => "Heading '#{heading}' not found in #{file}" } if start_i < 0
-        end_i = lines.size
-        (start_i + 1).upto(lines.size - 1) do |j|
-          stripped = lines[j].lstrip
-          next unless stripped.start_with?("#")
-          level = stripped.length - stripped.sub(/\A#+/, "").length
-          if level <= start_level
-            end_i = j
-            break
-          end
-        end
-        { "file" => file, "heading" => lines[start_i].strip, "body" => lines[start_i...end_i].join("\n") }
-      }, "Return a full markdown section from a framework doc file")
-
-      # ── Git / deps / project ──────────────────────────
-      server.register_tool("git_status", lambda {
-        Tina4::DevAdmin.send(:git_status_payload)
-      }, "Show git branch, modified/untracked files, recent commits")
-
-      server.register_tool("deps_list", lambda {
-        gemfile = File.join(Dir.pwd, "Gemfile")
-        return { "error" => "No Gemfile at project root" } unless File.file?(gemfile)
-        deps = File.read(gemfile).scan(/^\s*gem\s+["']([^"']+)["']/).flatten
-        { "name" => File.basename(Dir.pwd), "dependencies" => deps }
-      }, "List this project's declared Ruby dependencies")
-
-      server.register_tool("project_overview", lambda {
-        { "system" => { "framework" => "tina4-ruby", "version" => (defined?(Tina4::VERSION) ? Tina4::VERSION : "unknown"), "ruby" => RUBY_DESCRIPTION, "cwd" => project_root } }
-      }, "One-shot snapshot: system + project info")
-
-      # ── Project index ─────────────────────────────────
-      server.register_tool("index_rebuild", lambda {
-        Tina4::ProjectIndex.refresh
-      }, "Refresh the persistent project index (lazy, mtime-based)")
-
-      server.register_tool("index_search", lambda { |query:, limit: 20|
-        Tina4::ProjectIndex.search(query, limit.to_i)
-      }, "Find files by path, symbol, route, or summary")
-
-      server.register_tool("index_file", lambda { |path:|
-        Tina4::ProjectIndex.file_entry(path)
-      }, "Full index entry for one file")
-
-      server.register_tool("index_overview", lambda {
-        Tina4::ProjectIndex.overview
-      }, "Project shape: files by language, routes, models, recent edits")
-
-      # ── Plan management ───────────────────────────────
-      server.register_tool("plan_current", lambda {
-        Tina4::Plan.current
-      }, "The active plan: title, steps (done/not), next step, progress")
-
-      server.register_tool("plan_list", lambda {
-        Tina4::Plan.list_plans
-      }, "All plans in plan/ with progress and which one is active")
-
-      server.register_tool("plan_create", lambda { |title:, goal: "", steps: nil, make_current: true|
-        Tina4::Plan.create(title, goal: goal, steps: steps, make_current: make_current)
-      }, "Create a new markdown plan in plan/ and make it active")
-
-      server.register_tool("plan_switch_to", lambda { |name:|
-        Tina4::Plan.set_current(name)
-      }, "Make a different plan the active one")
-
-      server.register_tool("plan_complete_step", lambda { |index:|
-        Tina4::Plan.complete_step(index.to_i)
-      }, "Tick a step as done (call the moment the step finishes)")
-
-      server.register_tool("plan_add_step", lambda { |text:|
-        Tina4::Plan.add_step(text)
-      }, "Append a new unchecked step to the current plan")
-
-      server.register_tool("plan_note", lambda { |text:|
-        Tina4::Plan.append_note(text)
-      }, "Append a timestamped note/breadcrumb to the current plan")
-
-      server.register_tool("plan_archive", lambda { |name: ""|
-        Tina4::Plan.archive(name)
-      }, "Move a finished plan to plan/done/")
-
-      server.register_tool("plan_read", lambda { |name:|
-        Tina4::Plan.read(name)
-      }, "Full structured view of any plan by filename")
-
-      server.register_tool("plan_flesh", lambda { |name: "", prompt: ""|
-        Tina4::Plan.flesh(name, prompt)
-      }, "Auto-generate concrete build steps via AI and append them to an existing plan")
-
-      # ── Live API Docs (Live API RAG) ──────────────────
-      server.register_tool("api_search", lambda { |query:, k: 5, source: "all", include_private: false|
-        Tina4::Docs.cached(project_root).search(
-          query.to_s, k: k.to_i, source: source.to_s, include_private: include_private == true || include_private.to_s == "true"
-        )
-      }, "Search the live API index (framework + user code) for ranked hits")
-
-      server.register_tool("api_class", lambda { |name:|
-        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")
-
       # ── System Tools ──────────────────────────────────
       server.register_tool("system_info", lambda {
         {