tina4ruby 3.13.151 → 3.13.152

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2628729439684b6bb6c01c45a812c8e2e811bc8ad3da8848d4213311d3ecffa2
-  data.tar.gz: 78842ef5d13e8fd555baec8b1f25321390060d2be22fab7948de599a8c204fa4
+  metadata.gz: b90a1ada9ba0ccebf6ac21e8a8c6d37f01f444265b6520c853183a9c905fca98
+  data.tar.gz: 322fb1a149eb5181881eb12f0a78d628413ca0d7cd95a5baa8525fe70e9c43c0
 SHA512:
-  metadata.gz: c036143a0e8fc8206c6091e93d0a5f9d5e9af59f721afb5e33ebd48a86ba4a124b39fa8540ed8a0403e3474941484ad767152ad91775997289685e0c4c2cee7d
-  data.tar.gz: b61e7f1708946b5a9b3528a7b9cf1244bb0c9c064bd84661c76075b8f56c9ccf63f17f2b5733ee7514a0412a6c3b9387dab64ad01635c5c65cfccbeed9683072
+  metadata.gz: 40ab4de52acfa82a004929d03593662e64517c900dbecbf7a549ecb9b70a84e591ea8f091ef29c3571992ee7d384126757444a925fbc81ddcca40d7ab40f8303
+  data.tar.gz: b21e7652b9fa78befd3993cab32bd44798f6886f2267f00f6efeb8d42f869f242c05feb9424033c92c5f0bd246a0af5c0b3077f5693be333b49400c106f64b2d

data/CHANGELOG.md

@@ -6,6 +6,39 @@ 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.152 - 2026-10-20
+
+### Fixed
+- Database: the PostgreSQL adapter recovers after a dropped connection even
+  when the first reconnect attempt itself fails, so a query run over a dead
+  link no longer wedges once a reconnect failed (#242). Transaction control
+  (`BEGIN` / `COMMIT` / `ROLLBACK`) stays raw and surfaces its own failure, and
+  the in-transaction flag is cleared even when a commit or rollback raises.
+  Reconnect-after-drop is now at parity across Python, PHP and Node.js too
+  (#244).
+- CLI: `--help` / `-h` on any command prints that command's usage and changes
+  nothing. Before, most handlers never looked for it and ran for real:
+  `generate model -h` wrote a model named `-h`, `generate auth --help` wrote the
+  whole auth scaffold, `lint --help` ran `bundle add rubocop`, `migrate:status
+  --help` booted the app. Commands that used OptionParser printed its own banner
+  instead; every command now prints the same format. Exception: `serve` /
+  `start` keep `-h` as `--host` (`-h 127.0.0.1` still works); `--help` is help
+  everywhere. `help --help` prints the full reference.
+- CLI: an unknown option is refused with a did-you-mean (`--feilds` →
+  `--fields`) instead of being silently dropped, and a value option given no
+  value is refused instead of crashing (`serve --port` raised
+  `OptionParser::MissingArgument`, `--fields` generated a model with no fields
+  and exited 1) or being ignored (`--every`). `--name=value` works as well as
+  `--name value`. `test` reads no arguments, so it accepts no options.
+- CLI: `generate` refuses a name that starts with `-`.
+- CLI: `generate crud <Name> --skip-model` works. `generate model` has always
+  suggested it, but no generator had the option; it was silently ignored and
+  would now be refused.
+- CLI: `ai --all` installs every context file; it crashed with
+  `uninitialized constant Tina4::VERSION`. `ai all` works too.
+- CLI: the top-level help reads `Usage: tina4ruby <command> [options]`, the
+  same wording as the Python, PHP and Node CLIs (it said `COMMAND`).
+
 ## 3.13.151 - 2026-10-15
 
 ### Security

data/lib/tina4/ai.rb

@@ -9,6 +9,7 @@
 require "fileutils"
 require "net/http"
 require "uri"
+require_relative "version" # the context files name Tina4::VERSION; `ai` runs before lib/tina4 loads
 
 module Tina4
   # Tina4 AI -- Install AI coding assistant context files.

data/lib/tina4/cli.rb

@@ -7,6 +7,7 @@
 
 
 require "optparse"
+require "did_you_mean" # DidYouMean::SpellChecker - suggestions for a mistyped option
 require "fileutils"
 require "set"
 require "json"
@@ -27,33 +28,43 @@ module Tina4
     # mirror of the Python master's COMMANDS / GENERATORS registries
     # (tina4_python/cli/__init__.py).
     #
-    #   GENERATORS[name] = { handler: :method_symbol, usage: str, summary: str }
+    #   GENERATORS[name] = { handler: :method_symbol, flags: {...}, usage: str, summary: str }
     #   COMMANDS[name]   = { handler: :method_symbol, summary: str,
+    #                        flags: { name => bool }, # options #run accepts; true = takes a value.
+    #                                                 # nil = not checked (`help` prints the reference whatever follows)
+    #                        short?: { "p" => "port" }, # single-letter aliases (OptionParser ones)
     #                        usage?: str,          # arg/flag hint for #cmd_help (human only)
     #                        args?: [str],         # positional args for the manifest ("x?" = optional)
     #                        subcommands?: [str] } # sub-names for the manifest (generate)
     #
     # Handlers are instance-method symbols dispatched via #send: GENERATORS
-    # handlers take (name, flags); COMMANDS handlers take (argv).
+    # handlers take (name, flags); COMMANDS handlers take (argv). `flags` is
+    # what #check_options holds argv to before any handler runs; `generate` and
+    # `queue` take theirs from GENERATORS / QUEUE_FLAGS instead.
 
     GENERATORS = {
-      "model"      => { handler: :generate_model,      usage: '<Name> [--fields "name:string,price:float"] [--table-name <name>]', summary: "ORM model + matching migration" },
-      "route"      => { handler: :generate_route,      usage: "<name> [--model Name] [--public]",             summary: "CRUD route file, secure by default (--public opens writes)" },
-      "crud"       => { handler: :generate_crud,       usage: '<Name> [--fields "..."] [--public] [--no-templates]', summary: "Model + migration + AutoCrud-backed admin page (to_crud) + editable crud/ templates + gate test" },
-      "migration"  => { handler: :generate_migration,  usage: "<description>",                                 summary: "Timestamped migration file (UP/DOWN)" },
-      "middleware" => { handler: :generate_middleware, usage: "<Name>",                                        summary: "Middleware with before/after hooks" },
-      "test"       => { handler: :generate_test,       usage: "<name> [--model Name]",                         summary: "RSpec test file" },
-      "form"       => { handler: :generate_form,       usage: '<Name> [--fields "..."]',                       summary: "Form template with inputs matching model fields" },
-      "view"       => { handler: :generate_view,       usage: '<Name> [--fields "..."]',                       summary: "List + detail view templates" },
-      "auth"       => { handler: :generate_auth,       usage: "",                                              summary: "Login/register routes + User model + templates" },
-      "service"    => { handler: :generate_service,    usage: '<Name> [--every 5m | --cron "..."]',            summary: "Scheduled ServiceRunner task (src/services/)" },
-      "queue"      => { handler: :generate_queue,      usage: "<topic>",                                       summary: "Producer + consumer worker (src/services/)" },
-      "validator"  => { handler: :generate_validator,  usage: "<Name>",                                        summary: "Request-body Validator (src/validators/)" },
-      "seeder"     => { handler: :generate_seeder,     usage: "<Model>",                                       summary: "FakeData + seed_orm seeder (seeds/)" },
-      "websocket"  => { handler: :generate_websocket,  usage: "<path>",                                        summary: "Tina4.websocket handler (src/routes/)" },
-      "listener"   => { handler: :generate_listener,   usage: "<event>",                                       summary: "Tina4::Events.on listener (src/listeners/)" },
+      "model"      => { handler: :generate_model,      flags: { "fields" => true, "table-name" => true, "no-migration" => false }, usage: '<Name> [--fields "name:string,price:float"] [--table-name <name>]', summary: "ORM model + matching migration" },
+      "route"      => { handler: :generate_route,      flags: { "model" => true, "public" => false }, usage: "<name> [--model Name] [--public]",             summary: "CRUD route file, secure by default (--public opens writes)" },
+      "crud"       => { handler: :generate_crud,       flags: { "fields" => true, "table-name" => true, "public" => false, "no-templates" => false, "no-migration" => false, "skip-model" => false }, usage: '<Name> [--fields "..."] [--public] [--no-templates] [--skip-model]', summary: "Model + migration + AutoCrud-backed admin page (to_crud) + editable crud/ templates + gate test" },
+      "migration"  => { handler: :generate_migration,  flags: { "fields" => true },                   usage: "<description>",                                 summary: "Timestamped migration file (UP/DOWN)" },
+      "middleware" => { handler: :generate_middleware, flags: {},                                     usage: "<Name>",                                        summary: "Middleware with before/after hooks" },
+      "test"       => { handler: :generate_test,       flags: { "model" => true, "public" => false }, usage: "<name> [--model Name]",                         summary: "RSpec test file" },
+      "form"       => { handler: :generate_form,       flags: { "fields" => true, "table-name" => true }, usage: '<Name> [--fields "..."]',                   summary: "Form template with inputs matching model fields" },
+      "view"       => { handler: :generate_view,       flags: { "fields" => true, "table-name" => true }, usage: '<Name> [--fields "..."]',                   summary: "List + detail view templates" },
+      "auth"       => { handler: :generate_auth,       flags: {},                                     usage: "",                                              summary: "Login/register routes + User model + templates" },
+      "service"    => { handler: :generate_service,    flags: { "every" => true, "cron" => true },    usage: '<Name> [--every 5m | --cron "..."]',            summary: "Scheduled ServiceRunner task (src/services/)" },
+      "queue"      => { handler: :generate_queue,      flags: {},                                     usage: "<topic>",                                       summary: "Producer + consumer worker (src/services/)" },
+      "validator"  => { handler: :generate_validator,  flags: {},                                     usage: "<Name>",                                        summary: "Request-body Validator (src/validators/)" },
+      "seeder"     => { handler: :generate_seeder,     flags: { "table-name" => true },               usage: "<Model>",                                       summary: "FakeData + seed_orm seeder (seeds/)" },
+      "websocket"  => { handler: :generate_websocket,  flags: {},                                     usage: "<path>",                                        summary: "Tina4.websocket handler (src/routes/)" },
+      "listener"   => { handler: :generate_listener,   flags: {},                                     usage: "<event>",                                       summary: "Tina4::Events.on listener (src/listeners/)" },
     }.freeze
 
+    # Generators that emit the ADR-0063 resolution + JSON envelope, and the
+    # options every one of them accepts on top of its own.
+    RESOLUTION_TARGETS = %w[model route migration middleware form view queue].freeze
+    RESOLUTION_FLAGS = { "json" => false, "dry-run" => false }.freeze
+
     # Sub-dispatch table for the top-level `queue` command — the SINGLE source
     # for its subcommands (drives #cmd_queue dispatch AND the manifest's
     # queue.subcommands). Ruby mirror of the Python master's _QUEUE_SUBCOMMANDS.
@@ -65,27 +76,43 @@ module Tina4
       "clear" => :queue_clear,
     }.freeze
 
+    # Options per queue subcommand (name => takes a value), checked by #run.
+    QUEUE_FLAGS = {
+      "work"  => { "once" => false, "poll" => true, "services" => true },
+      "stats" => { "json" => false },
+      "retry" => {},
+      "clear" => {},
+    }.freeze
+
+    # `start` / `serve` options, as cmd_start's OptionParser defines them.
+    # `-h` is --host here (it predates per-command help), so only `--help` is
+    # help for these two.
+    SERVE_FLAGS = { "port" => true, "host" => true, "dev" => false, "managed" => false, "production" => false,
+                    "no-browser" => false, "no-reload" => false, "no-kill" => false }.freeze
+    SERVE_SHORT = { "p" => "port", "h" => "host", "d" => "dev" }.freeze
+    SERVE_USAGE = "[-p PORT] [-h HOST] [--dev] [--no-browser] [--no-reload] [--no-kill] [--production]"
+
     COMMANDS = {
-      "init"             => { handler: :cmd_init,             usage: "[NAME]", args: ["name?"],           summary: "Initialize a new Tina4 project" },
-      "start"            => { handler: :cmd_start,            usage: "[options]",                          summary: "Start the Tina4 web server" },
-      "serve"            => { handler: :cmd_start,                                                         summary: "Alias for start" },
-      "migrate"          => { handler: :cmd_migrate,          usage: "[--create NAME] [--rollback N]",     summary: "Run database migrations" },
-      "migrate:create"   => { handler: :cmd_migrate_create,   usage: "<desc>", args: ["description"],      summary: "Create a new migration file" },
-      "migrate:status"   => { handler: :cmd_migrate_status,                                                summary: "Show migration status (completed and pending)" },
-      "migrate:rollback" => { handler: :cmd_migrate_rollback, usage: "[-n N]",                             summary: "Rollback the last batch of migrations" },
-      "seed"             => { handler: :cmd_seed,             usage: "[--clear]",                          summary: "Run all seed files in seeds/" },
-      "seed:create"      => { handler: :cmd_seed_create,      usage: "NAME", args: ["name"],               summary: "Create a new seed file" },
-      "test"             => { handler: :cmd_test,                                                          summary: "Run inline tests" },
+      "init"             => { handler: :cmd_init,             flags: { "template" => true }, usage: "[NAME]", args: ["name?"],            summary: "Initialize a new Tina4 project" },
+      "start"            => { handler: :cmd_start,            flags: SERVE_FLAGS, short: SERVE_SHORT, usage: SERVE_USAGE, summary: "Start the Tina4 web server" },
+      "serve"            => { handler: :cmd_start,            flags: SERVE_FLAGS, short: SERVE_SHORT, usage: SERVE_USAGE, summary: "Alias for start" },
+      "migrate"          => { handler: :cmd_migrate,          flags: { "create" => true, "rollback" => true }, usage: "[--create NAME] [--rollback N]", summary: "Run database migrations" },
+      "migrate:create"   => { handler: :cmd_migrate_create,   flags: { "fields" => true, **RESOLUTION_FLAGS }, usage: "<desc>", args: ["description"], summary: "Create a new migration file" },
+      "migrate:status"   => { handler: :cmd_migrate_status,   flags: {},                                     summary: "Show migration status (completed and pending)" },
+      "migrate:rollback" => { handler: :cmd_migrate_rollback, flags: { "steps" => true }, short: { "n" => "steps" }, usage: "[-n N]", summary: "Rollback the last batch of migrations" },
+      "seed"             => { handler: :cmd_seed,             flags: { "clear" => false },                   usage: "[--clear]",                          summary: "Run all seed files in seeds/" },
+      "seed:create"      => { handler: :cmd_seed_create,      flags: {},                                     usage: "NAME", args: ["name"],               summary: "Create a new seed file" },
+      "test"             => { handler: :cmd_test,             flags: {},                                     summary: "Run inline tests" },
       "queue"            => { handler: :cmd_queue,            usage: "<work|stats|retry|clear> [topic]", subcommands: QUEUE_SUBCOMMANDS.keys, summary: "Run queue workers and manage jobs" },
-      "build"            => { handler: :cmd_build,            usage: "[--tag NAME] [--file PATH]",         summary: "Build the deployable Docker image" },
-      "lint"             => { handler: :cmd_lint,             usage: "[--fix] [--no-install]",             summary: "Lint src/ + app.rb (rubocop, installed dev-only on demand, else ruby -c)" },
-      "version"          => { handler: :cmd_version,                                                       summary: "Show Tina4 version" },
-      "routes"           => { handler: :cmd_routes,                                                        summary: "List all registered routes" },
-      "console"          => { handler: :cmd_console,                                                       summary: "Start an interactive console" },
+      "build"            => { handler: :cmd_build,            flags: { "tag" => true, "file" => true },      usage: "[--tag NAME] [--file PATH]",         summary: "Build the deployable Docker image" },
+      "lint"             => { handler: :cmd_lint,             flags: { "fix" => false, "no-install" => false }, usage: "[--fix] [--no-install]",          summary: "Lint src/ + app.rb (rubocop, installed dev-only on demand, else ruby -c)" },
+      "version"          => { handler: :cmd_version,          flags: {},                                     summary: "Show Tina4 version" },
+      "routes"           => { handler: :cmd_routes,           flags: {},                                     summary: "List all registered routes" },
+      "console"          => { handler: :cmd_console,          flags: {},                                     summary: "Start an interactive console" },
       "generate"         => { handler: :cmd_generate,         usage: "<what> <name> [options]", subcommands: GENERATORS.keys, summary: "Generate scaffolding (see Generators below)" },
-      "ai"               => { handler: :cmd_ai,               usage: "[--all]",                            summary: "Detect AI tools and install context files" },
-      "commands"         => { handler: :cmd_commands,         usage: "[--json]",                           summary: "List available commands (add --json for machine form)" },
-      "help"             => { handler: :cmd_help,                                                          summary: "Show this help message" },
+      "ai"               => { handler: :cmd_ai,               flags: { "all" => false },                     usage: "[--all]",                            summary: "Detect AI tools and install context files" },
+      "commands"         => { handler: :cmd_commands,         flags: { "json" => false },                    usage: "[--json]",                           summary: "List available commands (add --json for machine form)" },
+      "help"             => { handler: :cmd_help,             flags: nil,                                    summary: "Show this help message" },
     }.freeze
 
     # ── Delegation to the `tina4` client ────────────────────────────────
@@ -160,16 +187,34 @@ module Tina4
       new.run(argv)
     end
 
+    HELP_FLAGS = %w[--help -h].freeze
+
     def run(argv)
       command = argv.shift || "help"
-      command = "help" if %w[-h --help].include?(command)
+      command = "help" if HELP_FLAGS.include?(command)
 
       # Dispatch from the single-source-of-truth COMMANDS registry. The same
       # registry drives #cmd_help and the `commands --json` manifest, so
       # dispatch, help, and discovery never drift.
       spec = COMMANDS[command]
       if spec
-        send(spec[:handler], argv)
+        # `--help` / `-h` anywhere after a command prints that command's usage
+        # and touches nothing. Handlers never looked for it, so it ran the
+        # command for real: `generate model --help` wrote a model named
+        # `--help`, `migrate --help` opened the database. `serve` / `start`
+        # keep `-h` as --host. Delegated commands are left alone - the client
+        # answers --help itself.
+        if command != "help" && argv.any? { |arg| help_flags(command).include?(arg) }
+          command_help(command, argv)
+          return
+        end
+        check_options(command, argv)
+        begin
+          send(spec[:handler], argv)
+        rescue OptionParser::ParseError => e
+          # e.g. `serve --port abc`: say so, no backtrace.
+          option_error(command, "#{e.message}.")
+        end
       elsif DELEGATED.key?(command)
         exit delegate_to_client(command, argv)
       else
@@ -183,6 +228,113 @@ module Tina4
 
     private
 
+    # ── Per-command help and option checking ─────────────────────────────
+
+    def help_flags(command)
+      COMMANDS[command][:short]&.key?("h") ? ["--help"] : HELP_FLAGS
+    end
+
+    # Usage for one command (or one generator), from the same registries.
+    def command_help(command, argv)
+      if command == "generate"
+        kind = argv.find { |arg| !arg.start_with?("-") }&.downcase
+        if (gen = GENERATORS[kind])
+          puts "Usage: tina4ruby generate #{kind} #{gen[:usage]}".rstrip
+          puts "", "  #{gen[:summary]}"
+          return
+        end
+        puts "Usage: tina4ruby generate <what> <name> [options]", "", "Generators:"
+        pad = GENERATORS.keys.map(&:length).max
+        GENERATORS.each { |name, spec| puts "  #{name.ljust(pad)}  #{spec[:summary]}" }
+        return
+      end
+      spec = COMMANDS[command]
+      puts "Usage: tina4ruby #{command} #{spec[:usage]}".rstrip
+      puts "", "  #{spec[:summary]}"
+      puts "  Subcommands: #{spec[:subcommands].join(', ')}" if spec[:subcommands]
+    end
+
+    # The options `command` accepts ({ name => takes_value }), or nil when its
+    # arguments are not checked: `help` (flags: nil), or an unknown generator /
+    # queue subcommand, which its handler reports.
+    def accepted_options(command, argv)
+      kind = argv.first.to_s.downcase
+      case command
+      when "generate"
+        gen = GENERATORS[kind] or return nil
+        RESOLUTION_TARGETS.include?(kind) ? gen[:flags].merge(RESOLUTION_FLAGS) : gen[:flags]
+      when "queue"
+        QUEUE_FLAGS[kind]
+      else
+        COMMANDS[command].fetch(:flags, {})
+      end
+    end
+
+    def option_label(command, argv)
+      %w[generate queue].include?(command) ? "#{command} #{argv.first.downcase}" : command
+    end
+
+    def option_error(label, message)
+      puts message
+      puts %(Run "tina4ruby #{label} --help" for its options.)
+      exit 1
+    end
+
+    # Refuse an option the command doesn't have, or a value option given no
+    # value. Both used to slip through: `--feilds` was silently dropped (the
+    # model came out without its fields) and a bare `--fields` swallowed the
+    # next option or crashed OptionParser.
+    def check_options(command, argv)
+      accepted = accepted_options(command, argv)
+      return if accepted.nil?
+
+      label = option_label(command, argv)
+      short = COMMANDS[command][:short] || {}
+      i = 0
+      while i < argv.length
+        message, consumed = option_problem(argv, i, accepted, short, label)
+        if message
+          puts message
+          exit 1
+        end
+        i += consumed
+      end
+    end
+
+    # Judge argv[i]: [message, nil] when it is refused, else [nil, args consumed].
+    def option_problem(argv, i, accepted, short, label)
+      arg = argv[i]
+      return [nil, 1] unless arg.start_with?("-") && arg != "-"
+
+      name, has_value = option_name(arg, short)
+      return [unknown_option_message(arg, accepted, label), nil] unless name && accepted.key?(name)
+      return [nil, 1] unless accepted[name] && !has_value
+
+      value = argv[i + 1]
+      return [nil, 2] if value && !value.start_with?("-")
+
+      [%(Option --#{name} for "#{label}" needs a value: --#{name} <value>), nil]
+    end
+
+    # [long name, value attached?] for `--name`, `--name=value`, `-p` or `-p7147`;
+    # the name is nil for a short option the command doesn't alias.
+    def option_name(arg, short)
+      if arg.start_with?("--")
+        name, eq, = arg[2..].partition("=")
+        [name, !eq.empty?]
+      else
+        [short[arg[1]], arg.length > 2]
+      end
+    end
+
+    def unknown_option_message(arg, accepted, label)
+      bare = arg.sub(/\A-+/, "").partition("=").first
+      close = DidYouMean::SpellChecker.new(dictionary: accepted.keys).correct(bare).first
+      %(Unknown option #{arg.partition('=').first} for "#{label}".) +
+        (close ? " Did you mean --#{close}?" : "") +
+        %(\nRun "tina4ruby #{label} --help" for its options.)
+    end
+
     # Absolute path of the `tina4` client on PATH, or nil if it isn't there.
     #
     # Scans PATH directly rather than shelling out to which/where — one less
@@ -577,7 +729,11 @@ module Tina4
       positional = []
       i = 0
       while i < args.length
-        if args[i].start_with?("--")
+        if args[i].start_with?("--") && args[i].include?("=")
+          key, _, value = args[i][2..].partition("=")
+          flags[key] = value
+          i += 1
+        elsif args[i].start_with?("--")
           key = args[i][2..]
           if boolean_flags.include?(key)
             flags[key] = true
@@ -1444,6 +1600,7 @@ module Tina4
         opts.on("--all", "Install context for ALL AI tools (non-interactive)") { options[:all] = true }
       end
       parser.parse!(argv)
+      options[:all] = true if argv.first&.downcase == "all" # the Python master's bare form
 
       require_relative "ai"
 
@@ -1486,13 +1643,28 @@ module Tina4
         exit 1
       end
 
+      # Dispatch from the GENERATORS registry (single source of truth for the
+      # generate subcommands; also feeds #cmd_help and the manifest).
+      gen_spec = GENERATORS[what]
+      unless gen_spec
+        puts "Unknown generator: #{what}"
+        puts "  Available: #{all}"
+        exit 1
+      end
+
       # Auth doesn't require a name argument
       no_name_generators = %w[auth]
       unless no_name_generators.include?(what)
-        if argv.empty? || argv.first.start_with?("--")
+        if argv.empty?
           puts "Usage: tina4ruby generate #{what} <name> [options]"
           exit 1
         end
+        # A name that is really a mistyped option (`--fields` with no name
+        # before it, `-x`) would otherwise become a file called `--fields`.
+        if argv.first.start_with?("-")
+          puts "Invalid #{what} name: '#{argv.first}' - names can't start with '-'."
+          exit 1
+        end
       end
 
       name = no_name_generators.include?(what) ? "" : argv.shift
@@ -1501,21 +1673,11 @@ module Tina4
       json_mode = flags.delete("json") ? true : false
       dry_run   = flags.delete("dry-run") ? true : false
 
-      # Dispatch from the GENERATORS registry (single source of truth for the
-      # generate subcommands; also feeds #cmd_help and the manifest).
-      gen_spec = GENERATORS[what]
-      unless gen_spec
-        puts "Unknown generator: #{what}"
-        puts "  Available: #{all}"
-        exit 1
-      end
-
       # Only the resolution-aware targets emit a resolution + JSON envelope;
       # every other generator keeps its existing behaviour so nothing regresses.
       # ADR-0063 (3.13.121): form + view joined so their baked `{# tina4:edit ... #}`
       # markers surface in resolution.edit_hints[] under the same v1.1 envelope.
-      resolution_aware = %w[model route migration middleware form view queue]
-      if !resolution_aware.include?(what)
+      unless RESOLUTION_TARGETS.include?(what)
         send(gen_spec[:handler], name, flags)
         return
       end
@@ -2169,7 +2331,9 @@ module Tina4
 
       # 1. Model + migration (emit_test: false — crud emits its own broader gate
       #    spec at step 4, so the sub-generators stay quiet to avoid double-emit).
-      generate_model(name, flags, emit_test: false)
+      #    --skip-model: the model already exists (`generate model` suggests
+      #    exactly this), so leave it and its migration alone.
+      generate_model(name, flags, emit_test: false) unless flags["skip-model"]
 
       # 2. Admin page route: registers AutoCrud (secure-by-default; --public
       #    opens writes) and renders the to_crud admin UI at /admin/<table>.
@@ -3739,7 +3903,7 @@ module Tina4
         "  #{left.ljust(gap)}  #{summary}"
       end
 
-      lines = ["Tina4 Ruby CLI", "", "Usage: tina4ruby COMMAND [options]", "", "Commands:"]
+      lines = ["Tina4 Ruby CLI", "", "Usage: tina4ruby <command> [options]", "", "Commands:"]
       lines += command_rows.map { |left, summary| row.call(left, summary) }
       lines += ["", "Delegated to the #{CLIENT_BINARY} client (same behaviour in every framework):"]
       lines += delegated_rows.map { |left, summary| row.call(left, summary) }
@@ -3760,7 +3924,7 @@ module Tina4
         "",
         "https://tina4.com",
         "",
-        "Run 'tina4ruby COMMAND --help' for more information on a command.",
+        "Run 'tina4ruby <command> --help' for more information on a command.",
       ]
       puts lines.join("\n")
     end

data/lib/tina4/drivers/postgres_driver.rb

@@ -24,6 +24,7 @@ module Tina4
       attr_reader :connection
 
       def connect(connection_string, username: nil, password: nil)
+        @connect_args = [connection_string, username, password]
         begin
           require "pg"
         rescue LoadError
@@ -64,12 +65,51 @@ module Tina4
         @connection&.close
       end
 
+      # ── Reconnect after a dropped link (parity with the Python master #236/#242; #244) ──
+      # The pg gem does not reconnect itself: once the server drops the link
+      # (failover, idle reap, pg_terminate_backend) every exec raises until it is
+      # rebuilt. exec_with_reconnect heals a dead link BEFORE running, and on a
+      # connection error (not a real SQL error) reconnects and retries once when
+      # no explicit transaction owns the link. A reconnect that itself fails
+      # leaves @connection nil, so the NEXT statement rebuilds and recovers once
+      # a reachable server returns.
+      def connection_dead?
+        @connection.nil? || @connection.status == PG::CONNECTION_BAD
+      end
+
+      def reconnect
+        begin
+          @connection&.close
+        rescue StandardError
+          # already gone
+        end
+        @connection = nil
+        cs, user, pass = @connect_args
+        connect(cs, username: user, password: pass)
+      end
+
+      def exec_with_reconnect
+        reconnect if !@in_transaction && connection_dead?
+        begin
+          yield
+        rescue PG::Error => e
+          # A real SQL error leaves the link OK; only a dropped link outside an
+          # explicit transaction is reconnected and retried once.
+          raise e if @in_transaction || !connection_dead?
+
+          reconnect
+          yield
+        end
+      end
+
       def execute_query(sql, params = [])
-        result = if params.empty?
-                   @connection.exec(sql) # no params: sent exactly as written
-                 else
-                   @connection.exec_params(convert_placeholders(sql), params)
-                 end
+        result = exec_with_reconnect do
+          if params.empty?
+            @connection.exec(sql) # no params: sent exactly as written
+          else
+            @connection.exec_params(convert_placeholders(sql), params)
+          end
+        end
         track_affected(result)
         symbolize_result(result)
       end
@@ -82,11 +122,13 @@ module Tina4
         # Clear the cache so last_insert_id falls back to the lastval() probe,
         # which is the correct source for a sequence-backed bare INSERT.
         @last_returning_id = nil if sql.lstrip[0, 6].upcase == "INSERT"
-        result = if params.empty?
-                   @connection.exec(sql) # no params: sent exactly as written
-                 else
-                   @connection.exec_params(convert_placeholders(sql), params)
-                 end
+        result = exec_with_reconnect do
+          if params.empty?
+            @connection.exec(sql) # no params: sent exactly as written
+          else
+            @connection.exec_params(convert_placeholders(sql), params)
+          end
+        end
         track_affected(result)
         result
       end
@@ -206,14 +248,22 @@ module Tina4
 
       def begin_transaction
         @connection.exec("BEGIN")
+        @in_transaction = true # only after BEGIN actually opened the transaction
       end
 
       def commit
         @connection.exec("COMMIT")
+      ensure
+        # The transaction is over whether COMMIT succeeded or the link died.
+        # Clearing in `ensure` stops a COMMIT/ROLLBACK that raises on a dropped
+        # link from leaving the flag set and wedging every later reconnect (#244).
+        @in_transaction = false
       end
 
       def rollback
         @connection.exec("ROLLBACK")
+      ensure
+        @in_transaction = false
       end
 
       # v3.13.14 (#48): to_regclass resolves a (possibly schema-qualified)

data/lib/tina4/version.rb

@@ -7,5 +7,5 @@
 
 
 module Tina4
-  VERSION = "3.13.151"
+  VERSION = "3.13.152"
 end

metadata

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