tina4ruby 0.5.2 → 3.2.1

data/lib/tina4/cli.rb

@@ -1,32 +1,93 @@
 # frozen_string_literal: true
-require "thor"
+
+require "optparse"
 require "fileutils"
 
 module Tina4
-  class CLI < Thor
-    desc "init [NAME]", "Initialize a new Tina4 project"
-    option :template, type: :string, default: "default", desc: "Project template"
-    def init(name = ".")
-      dir = name == "." ? Dir.pwd : File.join(Dir.pwd, name)
+  class CLI
+    COMMANDS = %w[init start migrate seed seed:create test version routes console generate ai help].freeze
+
+    def self.start(argv)
+      new.run(argv)
+    end
+
+    def run(argv)
+      command = argv.shift || "help"
+      case command
+      when "init"       then cmd_init(argv)
+      when "start"      then cmd_start(argv)
+      when "migrate"    then cmd_migrate(argv)
+      when "seed"       then cmd_seed(argv)
+      when "seed:create" then cmd_seed_create(argv)
+      when "test"       then cmd_test(argv)
+      when "version"    then cmd_version
+      when "routes"     then cmd_routes
+      when "console"    then cmd_console
+      when "generate"   then cmd_generate(argv)
+      when "ai"         then cmd_ai(argv)
+      when "help", "-h", "--help" then cmd_help
+      else
+        puts "Unknown command: #{command}"
+        cmd_help
+        exit 1
+      end
+    end
+
+    private
+
+    # ── init ──────────────────────────────────────────────────────────────
+
+    def cmd_init(argv)
+      options = { template: "default" }
+      parser = OptionParser.new do |opts|
+        opts.banner = "Usage: tina4ruby init [PATH] [options]"
+        opts.on("--template TEMPLATE", "Project template (default: default)") { |v| options[:template] = v }
+      end
+      parser.parse!(argv)
+
+      name = argv.shift || "."
+      dir = File.expand_path(name)
       FileUtils.mkdir_p(dir)
 
+      project_name = File.basename(dir)
       create_project_structure(dir)
-      create_sample_files(dir, name == "." ? File.basename(Dir.pwd) : name)
+      create_sample_files(dir, project_name)
 
-      puts "Tina4 project initialized in #{dir}"
-      puts "Run 'cd #{name} && bundle install && tina4 start' to get started" unless name == "."
+      puts "\nProject scaffolded at #{dir}"
+      if name == "."
+        puts "  bundle install"
+        puts "  ruby app.rb"
+      else
+        puts "  cd #{dir}"
+        puts "  bundle install"
+        puts "  ruby app.rb"
+      end
     end
 
-    desc "start", "Start the Tina4 web server"
-    option :port, type: :numeric, default: 7145, aliases: "-p"
-    option :host, type: :string, default: "0.0.0.0", aliases: "-h"
-    option :dev, type: :boolean, default: false, aliases: "-d", desc: "Enable dev mode with auto-reload"
-    def start
+    # ── start ─────────────────────────────────────────────────────────────
+
+    def cmd_start(argv)
+      options = { port: nil, host: nil, dev: false }
+      parser = OptionParser.new do |opts|
+        opts.banner = "Usage: tina4ruby start [options]"
+        opts.on("-p", "--port PORT", Integer, "Port (default: 7147)") { |v| options[:port] = v }
+        opts.on("-h", "--host HOST", "Host (default: 0.0.0.0)") { |v| options[:host] = v }
+        opts.on("-d", "--dev", "Enable dev mode with auto-reload") { options[:dev] = true }
+      end
+      parser.parse!(argv)
+
+      # Priority: CLI flag > ENV var > default
+      options[:port] = resolve_config(:port, options[:port])
+      options[:host] = resolve_config(:host, options[:host])
+
       require_relative "../tina4"
 
       root_dir = Dir.pwd
       Tina4.initialize!(root_dir)
 
+      # Register health check endpoint
+      Tina4::Health.register!
+
       # Load route files
       load_routes(root_dir)
 
@@ -37,39 +98,58 @@ module Tina4
 
       app = Tina4::RackApp.new(root_dir: root_dir)
 
+      is_debug = Tina4::Env.truthy?(ENV["TINA4_DEBUG"])
+
       # Try Puma first (production-grade), fall back to WEBrick
-      begin
-        require "puma"
-        require "puma/configuration"
-        require "puma/launcher"
-
-        puma_host = options[:host]
-        puma_port = options[:port]
-
-        config = Puma::Configuration.new do |user_config|
-          user_config.bind "tcp://#{puma_host}:#{puma_port}"
-          user_config.app app
-          user_config.threads 0, 16
-          user_config.workers 0
-          user_config.environment "development"
-          user_config.log_requests false
-          user_config.quiet
-        end
+      # In debug mode, always use WEBrick for dev toolbar/reload support
+      if !is_debug
+        begin
+          require "puma"
+          require "puma/configuration"
+          require "puma/launcher"
+
+          puma_host = options[:host]
+          puma_port = options[:port]
+
+          config = Puma::Configuration.new do |user_config|
+            user_config.bind "tcp://#{puma_host}:#{puma_port}"
+            user_config.app app
+            user_config.threads 0, 16
+            user_config.workers 0
+            user_config.environment "production"
+            user_config.log_requests false
+            user_config.quiet
+          end
+
+          Tina4::Log.info("Production server: puma")
 
-        Tina4::Debug.info("Starting Puma server on http://#{puma_host}:#{puma_port}")
-        launcher = Puma::Launcher.new(config)
-        launcher.run
-      rescue LoadError
-        Tina4::Debug.info("Puma not found, falling back to WEBrick")
-        server = Tina4::WebServer.new(app, host: options[:host], port: options[:port])
-        server.start
+          # Setup graceful shutdown (Puma manages its own signals, but we handle DB cleanup)
+          Tina4::Shutdown.setup
+
+          launcher = Puma::Launcher.new(config)
+          launcher.run
+          return
+        rescue LoadError
+          # Puma not installed, fall through to WEBrick
+        end
       end
+
+      Tina4::Log.info("Development server: WEBrick")
+      server = Tina4::WebServer.new(app, host: options[:host], port: options[:port])
+      server.start
     end
 
-    desc "migrate", "Run database migrations"
-    option :create, type: :string, desc: "Create a new migration"
-    option :rollback, type: :numeric, desc: "Rollback N migrations"
-    def migrate
+    # ── migrate ───────────────────────────────────────────────────────────
+
+    def cmd_migrate(argv)
+      options = {}
+      parser = OptionParser.new do |opts|
+        opts.banner = "Usage: tina4ruby migrate [options]"
+        opts.on("--create NAME", "Create a new migration") { |v| options[:create] = v }
+        opts.on("--rollback N", Integer, "Rollback N migrations") { |v| options[:rollback] = v }
+      end
+      parser.parse!(argv)
+
       require_relative "../tina4"
       Tina4.initialize!(Dir.pwd)
 
@@ -100,8 +180,59 @@ module Tina4
       end
     end
 
-    desc "test", "Run inline tests"
-    def test
+    # ── seed ──────────────────────────────────────────────────────────────
+
+    def cmd_seed(argv)
+      options = { clear: false }
+      parser = OptionParser.new do |opts|
+        opts.banner = "Usage: tina4ruby seed [options]"
+        opts.on("--clear", "Clear tables before seeding") { options[:clear] = true }
+      end
+      parser.parse!(argv)
+
+      require_relative "../tina4"
+      Tina4.initialize!(Dir.pwd)
+      load_routes(Dir.pwd)
+      Tina4.seed(seed_folder: "seeds", clear: options[:clear])
+    end
+
+    # ── seed:create ───────────────────────────────────────────────────────
+
+    def cmd_seed_create(argv)
+      name = argv.shift
+      unless name
+        puts "Usage: tina4ruby seed:create NAME"
+        exit 1
+      end
+
+      dir = File.join(Dir.pwd, "seeds")
+      FileUtils.mkdir_p(dir)
+
+      existing = Dir.glob(File.join(dir, "*.rb")).select { |f| File.basename(f)[0] =~ /\d/ }.sort
+      numbers = existing.map { |f| File.basename(f).match(/^(\d+)/)[1].to_i }
+      next_num = numbers.empty? ? 1 : numbers.max + 1
+
+      clean_name = name.strip.downcase.gsub(/[^a-z0-9]+/, "_").gsub(/^_|_$/, "")
+      filename = format("%03d_%s.rb", next_num, clean_name)
+      filepath = File.join(dir, filename)
+
+      File.write(filepath, <<~RUBY)
+        # Seed: #{name.strip}
+        #
+        # This file is executed by `tina4ruby seed`.
+        # Use Tina4.seed_orm or Tina4.seed_table to populate data.
+        #
+        # Examples:
+        #   Tina4.seed_orm(User, count: 50)
+        #   Tina4.seed_table("audit_log", { action: :string, created_at: :datetime }, count: 100)
+      RUBY
+
+      puts "Created seed file: #{filepath}"
+    end
+
+    # ── test ──────────────────────────────────────────────────────────────
+
+    def cmd_test(argv)
       require_relative "../tina4"
       Tina4.initialize!(Dir.pwd)
 
@@ -121,14 +252,16 @@ module Tina4
       exit(1) if results[:failed] > 0 || results[:errors] > 0
     end
 
-    desc "version", "Show Tina4 version"
-    def version
+    # ── version ───────────────────────────────────────────────────────────
+
+    def cmd_version
       require_relative "version"
       puts "Tina4 Ruby v#{Tina4::VERSION}"
     end
 
-    desc "routes", "List all registered routes"
-    def routes
+    # ── routes ────────────────────────────────────────────────────────────
+
+    def cmd_routes
       require_relative "../tina4"
       Tina4.initialize!(Dir.pwd)
       load_routes(Dir.pwd)
@@ -143,53 +276,210 @@ module Tina4
       puts "Total: #{Tina4::Router.routes.length} routes\n"
     end
 
-    desc "seed", "Run all seed files in seeds/"
-    option :clear, type: :boolean, default: false, desc: "Clear tables before seeding"
-    def seed
+    # ── console ───────────────────────────────────────────────────────────
+
+    def cmd_console
       require_relative "../tina4"
       Tina4.initialize!(Dir.pwd)
       load_routes(Dir.pwd)
-      Tina4.seed(seed_folder: "seeds", clear: options[:clear])
+
+      require "irb"
+      IRB.start
     end
 
-    desc "seed:create NAME", "Create a new seed file"
-    def seed_create(name)
-      dir = File.join(Dir.pwd, "seeds")
+    # ── ai ────────────────────────────────────────────────────────────────
+
+    def cmd_ai(argv)
+      options = { all: false, force: false }
+      parser = OptionParser.new do |opts|
+        opts.banner = "Usage: tina4ruby ai [options]"
+        opts.on("--all", "Install context for ALL AI tools (not just detected ones)") { options[:all] = true }
+        opts.on("--force", "Overwrite existing context files") { options[:force] = true }
+      end
+      parser.parse!(argv)
+
+      require_relative "ai"
+
+      root_dir = Dir.pwd
+      puts Tina4::AI.status_report(root_dir)
+
+      if options[:all]
+        created = Tina4::AI.install_all(root_dir, force: options[:force])
+      else
+        created = Tina4::AI.install_ai_context(root_dir, force: options[:force])
+      end
+
+      if created.any?
+        puts "Created/updated context files:"
+        created.each { |f| puts "  #{f}" }
+      else
+        puts "No context files were created (files already exist; use --force to overwrite)."
+      end
+    end
+
+    # ── help ──────────────────────────────────────────────────────────────
+
+    # ── generate ────────────────────────────────────────────────────────
+
+    def cmd_generate(argv)
+      what = argv.shift
+      name = argv.shift
+      unless what && name
+        puts "Usage: tina4ruby generate <what> <name>"
+        puts "  Generators: model, route, migration, middleware"
+        exit 1
+      end
+
+      case what
+      when "model"    then generate_model(name)
+      when "route"    then generate_route(name)
+      when "migration" then generate_migration(name)
+      when "middleware" then generate_middleware(name)
+      else
+        puts "Unknown generator: #{what}"
+        puts "  Available: model, route, migration, middleware"
+        exit 1
+      end
+    end
+
+    def generate_model(name)
+      dir = "src/orm"
       FileUtils.mkdir_p(dir)
+      snake = name.gsub(/([A-Z])/) { |m| ($~.begin(0) > 0 ? "_" : "") + m.downcase }
+      path = File.join(dir, "#{snake}.rb")
+      abort "  File already exists: #{path}" if File.exist?(path)
+      File.write(path, <<~RUBY)
+        class #{name} < Tina4::ORM
+          integer_field :id, primary_key: true, auto_increment: true
+          string_field :name
+          string_field :email
+        end
+      RUBY
+      puts "  Created #{path}"
+    end
 
-      existing = Dir.glob(File.join(dir, "*.rb")).select { |f| File.basename(f)[0] =~ /\d/ }.sort
-      numbers = existing.map { |f| File.basename(f).match(/^(\d+)/)[1].to_i }
-      next_num = numbers.empty? ? 1 : numbers.max + 1
+    def generate_route(name)
+      route_path = name.sub(%r{^/}, "")
+      dir = "src/routes/#{route_path}"
+      FileUtils.mkdir_p(dir)
+      path = dir.chomp("/") + ".rb"
+      abort "  File already exists: #{path}" if File.exist?(path)
+      File.write(path, <<~RUBY)
+        Tina4.get "/#{route_path}" do |request, response|
+          response.json(data: [])
+        end
 
-      clean_name = name.strip.downcase.gsub(/[^a-z0-9]+/, "_").gsub(/^_|_$/, "")
-      filename = format("%03d_%s.rb", next_num, clean_name)
-      filepath = File.join(dir, filename)
+        Tina4.get "/#{route_path}/:id" do |request, response|
+          response.json(data: {})
+        end
 
-      File.write(filepath, <<~RUBY)
-        # Seed: #{name.strip}
-        #
-        # This file is executed by `tina4 seed`.
-        # Use Tina4.seed_orm or Tina4.seed_table to populate data.
-        #
-        # Examples:
-        #   Tina4.seed_orm(User, count: 50)
-        #   Tina4.seed_table("audit_log", { action: :string, created_at: :datetime }, count: 100)
+        Tina4.post "/#{route_path}" do |request, response|
+          response.json({ message: "created" }, 201)
+        end
+
+        Tina4.put "/#{route_path}/:id" do |request, response|
+          response.json(message: "updated")
+        end
+
+        Tina4.delete "/#{route_path}/:id" do |request, response|
+          response.json(message: "deleted")
+        end
       RUBY
+      puts "  Created #{path}"
+    end
 
-      puts "Created seed file: #{filepath}"
+    def generate_migration(name)
+      dir = "migrations"
+      FileUtils.mkdir_p(dir)
+      timestamp = Time.now.strftime("%Y%m%d%H%M%S")
+      table = name.sub(/^create_/, "")
+      table = if table.end_with?("s")
+                table
+              elsif table.end_with?("y")
+                table[0..-2] + "ies"
+              else
+                table + "s"
+              end
+      filename = "#{timestamp}_#{name}.sql"
+      path = File.join(dir, filename)
+      now = Time.now.strftime("%Y-%m-%d %H:%M:%S")
+      File.write(path, <<~SQL)
+        -- Migration: #{name}
+        -- Created: #{now}
+
+        CREATE TABLE #{table} (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            name TEXT NOT NULL,
+            email TEXT NOT NULL,
+            created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+        );
+      SQL
+      puts "  Created #{path}"
     end
 
-    desc "console", "Start an interactive console"
-    def console
-      require_relative "../tina4"
-      Tina4.initialize!(Dir.pwd)
-      load_routes(Dir.pwd)
+    def generate_middleware(name)
+      dir = "src/middleware"
+      FileUtils.mkdir_p(dir)
+      snake = name.gsub(/([A-Z])/) { |m| ($~.begin(0) > 0 ? "_" : "") + m.downcase }
+      path = File.join(dir, "#{snake}.rb")
+      abort "  File already exists: #{path}" if File.exist?(path)
+      File.write(path, <<~RUBY)
+        class #{name} < Tina4::Middleware
+          def process(request, response)
+            auth = request.headers["Authorization"]
+            return response.json({ error: "Unauthorized" }, 401) unless auth
+
+            nil
+          end
+        end
+      RUBY
+      puts "  Created #{path}"
+    end
 
-      require "irb"
-      IRB.start
+    def cmd_help
+      puts <<~HELP
+        Tina4 Ruby CLI
+
+        Usage: tina4ruby COMMAND [options]
+
+        Commands:
+          init [NAME]        Initialize a new Tina4 project
+          start              Start the Tina4 web server
+          migrate            Run database migrations
+          seed               Run all seed files in seeds/
+          seed:create NAME   Create a new seed file
+          test               Run inline tests
+          version            Show Tina4 version
+          routes             List all registered routes
+          console            Start an interactive console
+          generate <what> <name>  Generate scaffolding (model, route, migration, middleware)
+          ai                 Detect AI tools and install context files
+          help               Show this help message
+
+        Run 'tina4ruby COMMAND --help' for more information on a command.
+      HELP
     end
 
-    private
+    # ── config resolution ──────────────────────────────────────────────────
+
+    DEFAULT_PORT = 7147
+    DEFAULT_HOST = "0.0.0.0"
+
+    # Priority: CLI flag > ENV var > default
+    def resolve_config(key, cli_value)
+      case key
+      when :port
+        return cli_value if cli_value
+        return ENV["PORT"].to_i if ENV["PORT"] && !ENV["PORT"].empty?
+        DEFAULT_PORT
+      when :host
+        return cli_value if cli_value
+        return ENV["HOST"] if ENV["HOST"] && !ENV["HOST"].empty?
+        DEFAULT_HOST
+      end
+    end
+
+    # ── shared helpers ────────────────────────────────────────────────────
 
     def load_routes(root_dir)
       route_dirs = %w[routes src/routes src/api api]
@@ -209,8 +499,9 @@ module Tina4
 
     def create_project_structure(dir)
       %w[
-        routes templates public public/css public/js public/images
-        migrations src logs
+        src/routes src/orm src/templates src/templates/errors
+        src/public src/public/css src/public/js src/public/images
+        migrations logs
       ].each do |subdir|
         FileUtils.mkdir_p(File.join(dir, subdir))
       end
@@ -221,14 +512,9 @@ module Tina4
       unless File.exist?(File.join(dir, "app.rb"))
         File.write(File.join(dir, "app.rb"), <<~RUBY)
           require "tina4"
-
-          Tina4.get "/" do |request, response|
-            response.html "<h1>Welcome to #{project_name}!</h1><p>Powered by Tina4 Ruby</p>"
-          end
-
-          Tina4.get "/api/hello" do |request, response|
-            response.json({ message: "Hello from Tina4!", timestamp: Time.now.iso8601 })
-          end
+          Tina4.initialize!(__dir__)
+          app = Tina4::RackApp.new
+          Tina4::WebServer.new(app, port: 7147).start
         RUBY
       end
 
@@ -236,10 +522,18 @@ module Tina4
       unless File.exist?(File.join(dir, "Gemfile"))
         File.write(File.join(dir, "Gemfile"), <<~RUBY)
           source "https://rubygems.org"
-          gem "tina4ruby"
+          gem "tina4-ruby", "~> 3.0"
         RUBY
       end
 
+      # .env
+      unless File.exist?(File.join(dir, ".env"))
+        File.write(File.join(dir, ".env"), <<~TEXT)
+          TINA4_DEBUG=true
+          TINA4_LOG_LEVEL=ALL
+        TEXT
+      end
+
       # .gitignore
       unless File.exist?(File.join(dir, ".gitignore"))
         File.write(File.join(dir, ".gitignore"), <<~TEXT)
@@ -291,7 +585,7 @@ module Tina4
           # Copy application code
           COPY --from=builder /app /app
 
-          EXPOSE 7145
+          EXPOSE 7147
 
           # Swagger defaults (override with env vars in docker-compose/k8s if needed)
           ENV SWAGGER_TITLE="Tina4 API"
@@ -299,9 +593,8 @@ module Tina4
           ENV SWAGGER_DESCRIPTION="Auto-generated API documentation"
 
           # Start the server on all interfaces
-          CMD ["bundle", "exec", "tina4", "start", "-p", "7145", "-h", "0.0.0.0"]
+          CMD ["bundle", "exec", "tina4ruby", "start", "-p", "7147", "-h", "0.0.0.0"]
         DOCKERFILE
-        puts "  Created Dockerfile"
       end
 
       # .dockerignore
@@ -319,11 +612,10 @@ module Tina4
           spec/
           vendor/bundle
         TEXT
-        puts "  Created .dockerignore"
       end
 
       # Base template
-      templates_dir = File.join(dir, "templates")
+      templates_dir = File.join(dir, "src", "templates")
       unless File.exist?(File.join(templates_dir, "base.twig"))
         File.write(File.join(templates_dir, "base.twig"), <<~HTML)
           <!DOCTYPE html>
@@ -337,8 +629,8 @@ module Tina4
           </head>
           <body>
             {% block content %}{% endblock %}
-            <script src="/js/tina4.js"></script>
-            <script src="/js/tina4helper.js"></script>
+            <script src="/js/tina4.min.js"></script>
+            <script src="/js/frond.min.js"></script>
             {% block scripts %}{% endblock %}
           </body>
           </html>

data/lib/tina4/constants.rb

@@ -0,0 +1,46 @@
+# Tina4 Constants — HTTP status codes and content types.
+#
+# Standard constants for use in route handlers across all Tina4 frameworks.
+#
+#   Tina4.get "/api/users" do |request, response|
+#     response.call(users, Tina4::HTTP_OK)
+#   end
+
+module Tina4
+  # ── HTTP Status Codes ──
+
+  HTTP_OK = 200
+  HTTP_CREATED = 201
+  HTTP_ACCEPTED = 202
+  HTTP_NO_CONTENT = 204
+
+  HTTP_MOVED = 301
+  HTTP_REDIRECT = 302
+  HTTP_NOT_MODIFIED = 304
+
+  HTTP_BAD_REQUEST = 400
+  HTTP_UNAUTHORIZED = 401
+  HTTP_FORBIDDEN = 403
+  HTTP_NOT_FOUND = 404
+  HTTP_METHOD_NOT_ALLOWED = 405
+  HTTP_CONFLICT = 409
+  HTTP_GONE = 410
+  HTTP_UNPROCESSABLE = 422
+  HTTP_TOO_MANY = 429
+
+  HTTP_SERVER_ERROR = 500
+  HTTP_BAD_GATEWAY = 502
+  HTTP_UNAVAILABLE = 503
+
+  # ── Content Types ──
+
+  APPLICATION_JSON = "application/json"
+  APPLICATION_XML = "application/xml"
+  APPLICATION_FORM = "application/x-www-form-urlencoded"
+  APPLICATION_OCTET = "application/octet-stream"
+
+  TEXT_HTML = "text/html; charset=utf-8"
+  TEXT_PLAIN = "text/plain; charset=utf-8"
+  TEXT_CSV = "text/csv"
+  TEXT_XML = "text/xml"
+end