tina4ruby 3.13.150 → 3.13.152

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e63d80b48d2821411c3174e3307176cdf996bfc722c2c228be2b829df8a898c3
-  data.tar.gz: 4323b78fdba05283005597a4c8489d29a8b74cb02754bc9ec7b4c88f361d0cbc
+  metadata.gz: b90a1ada9ba0ccebf6ac21e8a8c6d37f01f444265b6520c853183a9c905fca98
+  data.tar.gz: 322fb1a149eb5181881eb12f0a78d628413ca0d7cd95a5baa8525fe70e9c43c0
 SHA512:
-  metadata.gz: 68483df7f4ae92df44d121678397b0c6a4884277e88c7321fc0ed57ba36e34ae26bb8bca3f148eed1904127907d2a0c20369ca729341131ebea409a3e47b799b
-  data.tar.gz: aa95f3c686a89537e480bdc2d49de82a1d8cec58dfe0e1c24398f8f19ea3552ba9ec2eac8a351ef859971400ed0756afe2e8421bcd4461ee4c02ffce21e6f715
+  metadata.gz: 40ab4de52acfa82a004929d03593662e64517c900dbecbf7a549ecb9b70a84e591ea8f091ef29c3571992ee7d384126757444a925fbc81ddcca40d7ab40f8303
+  data.tar.gz: b21e7652b9fa78befd3993cab32bd44798f6886f2267f00f6efeb8d42f869f242c05feb9424033c92c5f0bd246a0af5c0b3077f5693be333b49400c106f64b2d

data/CHANGELOG.md

@@ -6,6 +6,55 @@ 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
+- Cross-Origin-Opener-Policy joins the default security-header set (`TINA4_COOP`,
+  default `same-origin-allow-popups`). It pairs with a COEP header to unlock
+  `SharedArrayBuffer` and WASM threads in the browser.
+- S3 storage is a zero-dependency SigV4 client (no aws-sdk-s3). It now fails loud on
+  a missing credential, retries 429/5xx and dropped connections with capped backoff,
+  honours `Retry-After`, and keeps the endpoint path prefix.
+- MongoDB keeps bound values out of the parsed SQL text.
+- CRUD attributes are de-raw'd, the 302 redirect is guarded, CodeQL core findings
+  are cleared, and uploaded files are created owner-only (0600).
+
+### Docs
+- The README built-in feature count is corrected (55 -> 140).
+
 ## 3.13.150 — 2026-10-11
 
 ### Dev admin

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/auth.rb

@@ -466,7 +466,7 @@ module Tina4
       # is now honoured here too (explicit > env > HS256).
       def authenticate_request(headers, secret: nil, algorithm: nil)
         auth_header = headers["HTTP_AUTHORIZATION"] || headers["Authorization"] || ""
-        return nil unless auth_header =~ /\ABearer\s+(.+)\z/i
+        return nil unless auth_header =~ /\ABearer\s++(.+)\z/i
 
         token = Regexp.last_match(1)
 
@@ -518,7 +518,7 @@ module Tina4
       def bearer_auth
         lambda do |env|
           auth_header = env["HTTP_AUTHORIZATION"] || ""
-          return false unless auth_header =~ /\ABearer\s+(.+)\z/i
+          return false unless auth_header =~ /\ABearer\s++(.+)\z/i
 
           token = Regexp.last_match(1)
 
@@ -664,7 +664,7 @@ module Tina4
         auth_header = env["HTTP_AUTHORIZATION"] || ""
         return true if auth_header.empty?
 
-        if auth_header =~ /\ABearer\s+(.+)\z/i
+        if auth_header =~ /\ABearer\s++(.+)\z/i
           valid_token(Regexp.last_match(1))
         else
           false

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
@@ -457,7 +609,7 @@ module Tina4
     # per-instance to_snake_case when only the class name is known.
     def self.to_snake_case_static(name)
       s = name.to_s
-      s.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+      s.gsub(/([A-Z])(?=[A-Z][a-z])/, '\1_')
        .gsub(/([a-z\d])([A-Z])/, '\1_\2')
        .downcase
     end
@@ -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/crud.rb

@@ -112,7 +112,7 @@ module Tina4
         verb = method.to_s.upcase
         Tina4::Template.render("crud/form.twig", {
           "wrap" => true,
-          "form_id_attr" => "",
+          "form_id" => "",
           "action" => h(action),
           "form_method" => h(verb),
           "method_override" => (%w[PUT PATCH DELETE].include?(verb) ? verb : nil),
@@ -204,14 +204,14 @@ module Tina4
             "value" => "",
             "placeholder" => h("Enter #{label.downcase}"),
             "type" => "text",
-            "required_attr" => "",
+            "required" => false,
             "input" => true
           }
         end
 
         Tina4::Template.render("crud/form.twig", {
           "wrap" => true,
-          "form_id_attr" => " id=\"form-#{mode}\"",
+          "form_id" => "form-#{mode}",
           "action" => "",
           "form_method" => "POST",
           "method_override" => nil,
@@ -263,7 +263,7 @@ module Tina4
           "readonly" => !editable,
           "inline_script" => inline_script,
           "table_name" => h(table_name),
-          "table_id_attr" => (table_id ? " id=\"#{h(table_id)}\"" : "")
+          "table_id" => (table_id ? table_id.to_s : "")
         }
       end
 
@@ -309,7 +309,7 @@ module Tina4
         name     = field[:name].to_s
         label    = field[:label] || name.capitalize
         value    = field[:value]
-        required = field[:required] ? " required" : ""
+        required = field[:required] ? true : false
 
         base = {
           "id" => h(name),
@@ -317,14 +317,14 @@ module Tina4
           "label" => h(label.to_s),
           "value" => h(value.to_s),
           "placeholder" => "",
-          "required_attr" => required
+          "required" => required
         }
 
         case (field[:type] || :string).to_sym
         when :text
           base.merge("textarea" => true)
         when :boolean
-          base.merge("checkbox" => true, "checked_attr" => (value ? " checked" : ""))
+          base.merge("checkbox" => true, "checked" => (value ? true : false))
         when :select
           base.merge("select" => true, "options_html" => build_options(field[:options], value))
         when :date