tina4ruby 3.11.14 → 3.11.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0306b1bed1468e9d48729f576f4494f01f0ba42bd0868f137c56a533d4d3a987
-  data.tar.gz: 500e0e589914771bdc96b5b901dc0b9948ecf901df072b0ed845fd31efe7ff34
+  metadata.gz: a33bdb237a1acedfe4903a9145ded69e405e9e63403c9a8c2e548795060d2740
+  data.tar.gz: bf61f8a4a84be8f910c9767a23437ec8fbc4820fb3eb05da3ef73657b16f2585
 SHA512:
-  metadata.gz: 225d391063a44527dc0df900ee7cce8fa20151be48a6a786fd41e2f6130253cff8899e1939a1a067e2d3f6879463f8b5cd7c888a85af29baaac85c8608a1607e
-  data.tar.gz: 0ece15acd6ebdeef69e90f67e10b250a3c1e05dee513ea3fad2f5794df93abc10141471362e59040bcff03f3aeeb2986dc4e7e6e1e1670a7721e26af82e0d902
+  metadata.gz: 1c43c2556e8b8b742a1cb1cb52e26b011b1c64b56cdfb636fbfdf569789f0c7fa0d25094a201cda3d301fc9982832acfe60c01c4221b033e58a41dc6b06e7eea
+  data.tar.gz: 8b38f262f9a5e41f3635000b22668200127c20cfe864bc18b316758ebbefeb58c4a4022961e929b0213a3a0e1657becf2348cdbcecf79c37f3f9561f7fa3bbdc

data/lib/tina4/dev_admin.rb

@@ -5,6 +5,8 @@ require "digest"
 require "tmpdir"
 require "net/http"
 require "uri"
+require "fileutils"
+require "shellwords"
 require_relative "metrics"
 
 module Tina4
@@ -494,6 +496,56 @@ module Tina4
         when ["GET", "/__dev/api/metrics/file"]
           file_path = (query_param(env, "path") || "").to_s
           json_response(Tina4::Metrics.file_detail(file_path))
+        when ["GET", "/__dev/api/thoughts"]
+          json_response(thoughts_payload)
+        when ["POST", "/__dev/api/supervise/create"]
+          body = read_json_body(env) || {}
+          json_response(proxy_supervisor("/supervise/create", method: "POST", body: body))
+        when ["GET", "/__dev/api/supervise/sessions"]
+          json_response(proxy_supervisor("/supervise/sessions", method: "GET", query: env["QUERY_STRING"]))
+        when ["GET", "/__dev/api/supervise/diff"]
+          json_response(proxy_supervisor("/supervise/diff", method: "GET", query: env["QUERY_STRING"]))
+        when ["POST", "/__dev/api/supervise/commit"]
+          body = read_json_body(env) || {}
+          json_response(proxy_supervisor("/supervise/commit", method: "POST", body: body))
+        when ["POST", "/__dev/api/supervise/cancel"]
+          body = read_json_body(env) || {}
+          json_response(proxy_supervisor("/supervise/cancel", method: "POST", body: body))
+        when ["POST", "/__dev/api/execute"]
+          body = read_json_body(env) || {}
+          execute_proxy(body)
+        when ["GET", "/__dev/api/files"]
+          json_response(files_list(env))
+        when ["GET", "/__dev/api/file"]
+          json_response(file_read_payload(query_param(env, "path")))
+        when ["GET", "/__dev/api/file/raw"]
+          file_raw_response(query_param(env, "path"))
+        when ["POST", "/__dev/api/file/save"]
+          body = read_json_body(env) || {}
+          json_response(file_save(body))
+        when ["POST", "/__dev/api/file/rename"]
+          body = read_json_body(env) || {}
+          json_response(file_rename(body))
+        when ["POST", "/__dev/api/file/delete"]
+          body = read_json_body(env) || {}
+          json_response(file_delete(body))
+        when ["GET", "/__dev/api/deps/search"]
+          json_response(deps_search(query_param(env, "q") || query_param(env, "query") || ""))
+        when ["POST", "/__dev/api/deps/install"]
+          body = read_json_body(env) || {}
+          json_response(deps_install(body))
+        when ["GET", "/__dev/api/git/status"]
+          json_response(git_status_payload)
+        when ["GET", "/__dev/api/mcp/tools"]
+          json_response(mcp_tools_list)
+        when ["POST", "/__dev/api/mcp/call"]
+          body = read_json_body(env) || {}
+          json_response(mcp_tool_call(body))
+        when ["GET", "/__dev/api/scaffold"]
+          json_response(scaffold_templates)
+        when ["POST", "/__dev/api/scaffold/run"]
+          body = read_json_body(env) || {}
+          json_response(scaffold_run(body))
         when ["GET", "/__dev/api/graphql/schema"]
           begin
             gql = Tina4::GraphQL.new
@@ -930,6 +982,308 @@ module Tina4
 
         { deployed: name, files: copied }
       end
+
+      # ── New dev-admin surface area (parity with Python/PHP) ────
+
+      def supervisor_base
+        base = ENV["TINA4_SUPERVISOR_URL"].to_s.strip
+        return base unless base.empty?
+        port = (ENV["TINA4_PORT"] || ENV["PORT"] || "7147").to_i + 2000
+        "http://127.0.0.1:#{port}"
+      end
+
+      def thoughts_payload
+        base = supervisor_base
+        begin
+          uri = URI.parse("#{base}/thoughts")
+          req = Net::HTTP::Get.new(uri)
+          resp = Net::HTTP.start(uri.host, uri.port, open_timeout: 2, read_timeout: 5) { |h| h.request(req) }
+          return JSON.parse(resp.body) if resp.is_a?(Net::HTTPSuccess)
+          { thoughts: [], error: "Supervisor returned #{resp.code}" }
+        rescue StandardError => e
+          { thoughts: [], error: e.message }
+        end
+      end
+
+      def proxy_supervisor(path, method: "GET", body: nil, query: nil)
+        base = supervisor_base
+        url = "#{base}#{path}"
+        url += "?#{query}" if query && !query.empty?
+        begin
+          uri = URI.parse(url)
+          req = case method.upcase
+                when "POST"
+                  r = Net::HTTP::Post.new(uri)
+                  r["Content-Type"] = "application/json"
+                  r.body = JSON.generate(body || {})
+                  r
+                else
+                  Net::HTTP::Get.new(uri)
+                end
+          resp = Net::HTTP.start(uri.host, uri.port, open_timeout: 2, read_timeout: 30) { |h| h.request(req) }
+          begin
+            JSON.parse(resp.body)
+          rescue JSON::ParserError
+            { body: resp.body, status: resp.code.to_i }
+          end
+        rescue StandardError => e
+          { error: e.message, supervisor: base }
+        end
+      end
+
+      def execute_proxy(body)
+        # Proxy POST /execute to the supervisor at framework_port + 2000.
+        # Pass through the response stream as-is (SSE or JSON).
+        base = supervisor_base
+        begin
+          uri = URI.parse("#{base}/execute")
+          req = Net::HTTP::Post.new(uri)
+          req["Content-Type"] = "application/json"
+          req["Accept"] = "text/event-stream"
+          req.body = JSON.generate(body || {})
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.open_timeout = 2
+          http.read_timeout = 300
+          resp = http.request(req)
+          ct = resp["content-type"] || "application/json; charset=utf-8"
+          [resp.code.to_i, { "content-type" => ct }, [resp.body.to_s]]
+        rescue StandardError => e
+          body_str = JSON.generate({ error: e.message, supervisor: base })
+          [502, { "content-type" => "application/json; charset=utf-8" }, [body_str]]
+        end
+      end
+
+      def safe_project_path(rel_path)
+        root = File.expand_path(Dir.pwd)
+        resolved = File.expand_path(rel_path.to_s, root)
+        raise ArgumentError, "path escapes project directory" unless resolved.start_with?(root)
+        resolved
+      end
+
+      def files_list(env)
+        rel = query_param(env, "path") || "."
+        begin
+          target = safe_project_path(rel)
+          return { error: "Not found" } unless File.exist?(target)
+          return { error: "Not a directory" } unless File.directory?(target)
+          entries = Dir.children(target).sort.map do |name|
+            full = File.join(target, name)
+            {
+              name: name,
+              type: File.directory?(full) ? "dir" : "file",
+              size: File.file?(full) ? File.size(full) : 0
+            }
+          end
+          { path: rel, entries: entries, count: entries.size }
+        rescue => e
+          { error: e.message }
+        end
+      end
+
+      def file_read_payload(rel)
+        return { error: "path required" } if rel.nil? || rel.empty?
+        begin
+          target = safe_project_path(rel)
+          return { error: "Not found" } unless File.exist?(target)
+          return { error: "Not a file" } unless File.file?(target)
+          content = File.read(target, encoding: "utf-8", invalid: :replace, undef: :replace)
+          { path: rel, content: content, bytes: File.size(target) }
+        rescue => e
+          { error: e.message }
+        end
+      end
+
+      def file_raw_response(rel)
+        return json_response({ error: "path required" }) if rel.nil? || rel.empty?
+        begin
+          target = safe_project_path(rel)
+          return json_response({ error: "Not found" }) unless File.file?(target)
+          content = File.binread(target)
+          ct = case File.extname(target).downcase
+               when ".css" then "text/css"
+               when ".js"  then "application/javascript"
+               when ".json" then "application/json"
+               when ".html", ".htm" then "text/html"
+               when ".png" then "image/png"
+               when ".jpg", ".jpeg" then "image/jpeg"
+               when ".gif" then "image/gif"
+               when ".svg" then "image/svg+xml"
+               else "text/plain; charset=utf-8"
+               end
+          [200, { "content-type" => ct }, [content]]
+        rescue => e
+          json_response({ error: e.message })
+        end
+      end
+
+      def file_save(body)
+        rel     = body["path"].to_s
+        content = body["content"].to_s
+        return { error: "path required" } if rel.empty?
+        begin
+          target = safe_project_path(rel)
+          existed = File.exist?(target)
+          FileUtils.mkdir_p(File.dirname(target))
+          File.write(target, content, encoding: "utf-8")
+          Tina4::Plan.record_action(existed ? "patched" : "created", rel) if defined?(Tina4::Plan)
+          { saved: rel, bytes: content.bytesize }
+        rescue => e
+          { error: e.message }
+        end
+      end
+
+      def file_rename(body)
+        from = body["from"].to_s
+        to   = body["to"].to_s
+        return { error: "from/to required" } if from.empty? || to.empty?
+        begin
+          src = safe_project_path(from)
+          dst = safe_project_path(to)
+          return { error: "Source not found" } unless File.exist?(src)
+          FileUtils.mkdir_p(File.dirname(dst))
+          File.rename(src, dst)
+          { renamed: { from: from, to: to } }
+        rescue => e
+          { error: e.message }
+        end
+      end
+
+      def file_delete(body)
+        rel = body["path"].to_s
+        return { error: "path required" } if rel.empty?
+        begin
+          target = safe_project_path(rel)
+          return { error: "Not found" } unless File.exist?(target)
+          if File.directory?(target)
+            FileUtils.rm_rf(target)
+          else
+            File.delete(target)
+          end
+          { deleted: rel }
+        rescue => e
+          { error: e.message }
+        end
+      end
+
+      def deps_search(query)
+        return { results: [], count: 0, error: "query required" } if query.to_s.strip.empty?
+        begin
+          uri = URI.parse("https://rubygems.org/api/v1/search.json?query=#{URI.encode_www_form_component(query)}")
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = true
+          http.open_timeout = 5
+          http.read_timeout = 8
+          resp = http.request(Net::HTTP::Get.new(uri))
+          if resp.is_a?(Net::HTTPSuccess)
+            gems = JSON.parse(resp.body)
+            results = gems.first(20).map do |g|
+              { name: g["name"], version: g["version"], info: g["info"].to_s[0, 200] }
+            end
+            { results: results, count: results.size }
+          else
+            { results: [], count: 0, error: "rubygems returned #{resp.code}" }
+          end
+        rescue => e
+          { results: [], count: 0, error: e.message }
+        end
+      end
+
+      def deps_install(body)
+        name = body["name"].to_s.strip
+        return { ok: false, error: "name required" } if name.empty?
+        # Append to Gemfile if not present — do NOT actually bundle install.
+        gemfile = File.join(Dir.pwd, "Gemfile")
+        return { ok: false, error: "No Gemfile at project root" } unless File.exist?(gemfile)
+        content = File.read(gemfile)
+        if content.include?("gem \"#{name}\"") || content.include?("gem '#{name}'")
+          return { ok: true, gem: name, note: "already in Gemfile" }
+        end
+        File.open(gemfile, "a") { |f| f.write("\ngem \"#{name}\"\n") }
+        { ok: true, gem: name, note: "added to Gemfile; run `bundle install`" }
+      end
+
+      def git_status_payload
+        begin
+          inside = `cd #{Shellwords.escape(Dir.pwd)} && git rev-parse --is-inside-work-tree 2>/dev/null`.strip
+          return { error: "Not a git repository" } if inside != "true"
+          branch = `cd #{Shellwords.escape(Dir.pwd)} && git branch --show-current 2>/dev/null`.strip
+          status = `cd #{Shellwords.escape(Dir.pwd)} && git status --porcelain 2>/dev/null`.strip.split("\n").reject(&:empty?)
+          recent = `cd #{Shellwords.escape(Dir.pwd)} && git log --oneline -5 2>/dev/null`.strip.split("\n").reject(&:empty?)
+          { branch: branch, status: status, recent_commits: recent }
+        rescue => e
+          { error: "git unavailable: #{e.message}" }
+        end
+      end
+
+      def mcp_tools_list
+        return { tools: [], count: 0 } unless defined?(Tina4::McpServer)
+        server = Tina4._default_mcp_server
+        list = server.tools.values.map do |t|
+          { name: t["name"], description: t["description"], schema: t["inputSchema"] }
+        end
+        { tools: list, count: list.size }
+      end
+
+      def mcp_tool_call(body)
+        tool_name = body["name"].to_s
+        args      = body["arguments"] || {}
+        return { error: "tool name required" } if tool_name.empty?
+        return { error: "MCP not loaded" } unless defined?(Tina4::McpServer)
+        server = Tina4._default_mcp_server
+        payload = JSON.generate({
+          "jsonrpc" => "2.0",
+          "id"      => 1,
+          "method"  => "tools/call",
+          "params"  => { "name" => tool_name, "arguments" => args }
+        })
+        raw = server.handle_message(payload)
+        return {} if raw.nil? || raw.empty?
+        JSON.parse(raw)
+      end
+
+      def scaffold_templates
+        # Expose built-in scaffold targets for the dev-admin UI.
+        { templates: [
+          { id: "route",      label: "Route file",           target: "src/routes" },
+          { id: "model",      label: "ORM model",            target: "src/orm" },
+          { id: "migration",  label: "SQL migration",        target: "migrations" },
+          { id: "middleware", label: "Middleware class",     target: "src/app" }
+        ] }
+      end
+
+      def scaffold_run(body)
+        kind = body["kind"].to_s
+        name = body["name"].to_s.strip
+        return { ok: false, error: "kind + name required" } if kind.empty? || name.empty?
+        project = Dir.pwd
+        case kind
+        when "route"
+          target = File.join(project, "src", "routes", "#{name}.rb")
+          FileUtils.mkdir_p(File.dirname(target))
+          File.write(target, "# #{name} routes\nTina4::Router.get(\"/api/#{name}\") do |req, res|\n  res.call({ hello: \"#{name}\" })\nend\n") unless File.exist?(target)
+          { ok: true, created: target.sub("#{project}/", "") }
+        when "model"
+          target = File.join(project, "src", "orm", "#{name}.rb")
+          FileUtils.mkdir_p(File.dirname(target))
+          cls = name.to_s.split(/[_-]/).map(&:capitalize).join
+          File.write(target, "class #{cls} < Tina4::ORM\n  integer_field :id, primary_key: true, auto_increment: true\n  string_field :name\nend\n") unless File.exist?(target)
+          { ok: true, created: target.sub("#{project}/", "") }
+        when "migration"
+          ts = Time.now.strftime("%Y%m%d%H%M%S")
+          target = File.join(project, "migrations", "#{ts}_#{name}.sql")
+          FileUtils.mkdir_p(File.dirname(target))
+          File.write(target, "-- migration: #{name}\n")
+          { ok: true, created: target.sub("#{project}/", "") }
+        when "middleware"
+          target = File.join(project, "src", "app", "#{name}.rb")
+          FileUtils.mkdir_p(File.dirname(target))
+          cls = name.to_s.split(/[_-]/).map(&:capitalize).join
+          File.write(target, "class #{cls}\n  def self.before_check(req, res); [req, res]; end\nend\n") unless File.exist?(target)
+          { ok: true, created: target.sub("#{project}/", "") }
+        else
+          { ok: false, error: "unknown kind: #{kind}" }
+        end
+      end
     end
   end
 end

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,181 @@ 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")
+
       # ── System Tools ──────────────────────────────────
       server.register_tool("system_info", lambda {
         {