tina4ruby 3.11.35 → 3.11.36

data/lib/tina4/frond.rb

@@ -548,6 +548,20 @@ 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) }
@@ -611,6 +625,19 @@ 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
@@ -756,6 +783,41 @@ 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,6 +680,196 @@ 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 {
         {

data/lib/tina4/orm.rb

@@ -52,15 +52,31 @@ module Tina4
         @field_mapping = map
       end
 
-      # Auto-map flag (no-op in Ruby since snake_case is native)
+      # Auto-map flag — defaults to TRUE for cross-framework parity (Python's
+      # ORM has auto_map=True by default). The instance variable is treated
+      # as "unset" when nil; only an explicit `false` disables it.
       def auto_map
-        @auto_map || false
+        defined?(@auto_map) && !@auto_map.nil? ? @auto_map : true
       end
 
       def auto_map=(val)
         @auto_map = val
       end
 
+      # auto_crud flag — when set to true, the class registers itself with
+      # Tina4::AutoCrud which auto-generates REST endpoints from the model.
+      # Defaults to false. Cross-framework parity with Python's autoCrud.
+      def auto_crud
+        defined?(@auto_crud) && !@auto_crud.nil? ? @auto_crud : false
+      end
+
+      def auto_crud=(val)
+        @auto_crud = val
+        if val && defined?(::Tina4::AutoCrud)
+          ::Tina4::AutoCrud.models << self unless ::Tina4::AutoCrud.models.include?(self)
+        end
+      end
+
       # Relationship definitions
       def relationship_definitions
         @relationship_definitions ||= {}
@@ -343,8 +359,10 @@ module Tina4
         instance
       end
 
-      private
-
+      # find_by_id is PUBLIC — cross-framework parity with Python's
+      # MyModel.find_by_id(pk_value) and PHP's User::find($id). Spec at
+      # spec/orm_spec.rb:78 verifies public access. find_by_filter stays
+      # public for the same reason; both are part of the documented API.
       def find_by_id(id)
         pk = primary_key_field || :id
         sql = "SELECT * FROM #{table_name} WHERE #{pk} = ?"
@@ -474,15 +492,30 @@ module Tina4
       errors
     end
 
-    def load(id = nil)
-      pk = self.class.primary_key_field || :id
-      id ||= __send__(pk)
-      return false unless id
+    # load — populate this instance from the database.
+    #
+    # Three forms (parity with Python's model.load(sql, params, include)):
+    #   user.load                                   # reload by primary key from instance
+    #   user.load(123)                              # load by primary key value
+    #   user.load("email = ?", ["a@b.c"])           # load by filter SQL + params (selectOne)
+    #
+    # Returns true on hit, false on miss. Always clears the relationship cache.
+    def load(arg = nil, params = nil)
       @relationship_cache = {} # Clear relationship cache on reload
+      pk = self.class.primary_key_field || :id
 
-      result = self.class.db.fetch_one(
-        "SELECT * FROM #{self.class.table_name} WHERE #{pk} = ?", [id]
-      )
+      if arg.is_a?(String)
+        # Filter-SQL form: user.load("email = ?", ["a@b.c"])
+        sql = "SELECT * FROM #{self.class.table_name} WHERE #{arg} LIMIT 1"
+        result = self.class.db.fetch_one(sql, params || [])
+      else
+        # Primary-key form: user.load OR user.load(123)
+        id = arg || __send__(pk)
+        return false unless id
+        result = self.class.db.fetch_one(
+          "SELECT * FROM #{self.class.table_name} WHERE #{pk} = ?", [id]
+        )
+      end
       return false unless result
 
       mapping_reverse = self.class.field_mapping.invert
@@ -505,7 +538,10 @@ module Tina4
 
     # Convert to hash using Ruby attribute names.
     # Optionally include relationships via the include keyword.
-    def to_h(include: nil)
+    # case: "camel" converts snake_case keys to camelCase (parity with
+    # Python's to_dict(case='camel')). Default keeps native snake_case.
+    def to_h(include: nil, case: nil)
+      key_case = binding.local_variable_get(:case)  # :case is a reserved word
       hash = {}
       self.class.field_definitions.each_key do |name|
         hash[name] = __send__(name)
@@ -534,6 +570,15 @@ module Tina4
         end
       end
 
+      if key_case == "camel" || key_case == :camel
+        # snake_case → camelCase: split on _, capitalize all but the first
+        hash = hash.each_with_object({}) do |(k, v), out|
+          parts = k.to_s.split("_")
+          camel = parts[0] + parts[1..].map(&:capitalize).join
+          out[camel.to_sym] = v
+        end
+      end
+
       hash
     end