tina4ruby 0.5.2 → 3.0.0

data/lib/tina4/cli.rb

@@ -1,32 +1,92 @@
 # 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 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 "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)
 
@@ -56,20 +116,31 @@ module Tina4
           user_config.quiet
         end
 
-        Tina4::Debug.info("Starting Puma server on http://#{puma_host}:#{puma_port}")
+        Tina4::Log.info("Starting Puma server on http://#{puma_host}:#{puma_port}")
+
+        # Setup graceful shutdown (Puma manages its own signals, but we handle DB cleanup)
+        Tina4::Shutdown.setup
+
         launcher = Puma::Launcher.new(config)
         launcher.run
       rescue LoadError
-        Tina4::Debug.info("Puma not found, falling back to WEBrick")
+        Tina4::Log.info("Puma not found, falling back to WEBrick")
         server = Tina4::WebServer.new(app, host: options[:host], port: options[:port])
         server.start
       end
     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 +171,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 +243,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 +267,92 @@ 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")
-      FileUtils.mkdir_p(dir)
+    # ── ai ────────────────────────────────────────────────────────────────
 
-      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 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)
 
-      clean_name = name.strip.downcase.gsub(/[^a-z0-9]+/, "_").gsub(/^_|_$/, "")
-      filename = format("%03d_%s.rb", next_num, clean_name)
-      filepath = File.join(dir, filename)
+      require_relative "ai"
 
-      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)
-      RUBY
+      root_dir = Dir.pwd
+      puts Tina4::AI.status_report(root_dir)
 
-      puts "Created seed file: #{filepath}"
+      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
 
-    desc "console", "Start an interactive console"
-    def console
-      require_relative "../tina4"
-      Tina4.initialize!(Dir.pwd)
-      load_routes(Dir.pwd)
+    # ── help ──────────────────────────────────────────────────────────────
+
+    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
+          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
 
-      require "irb"
-      IRB.start
+    # ── 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
 
-    private
+    # ── shared helpers ────────────────────────────────────────────────────
 
     def load_routes(root_dir)
       route_dirs = %w[routes src/routes src/api api]
@@ -209,8 +372,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 +385,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 +395,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 +458,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 +466,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 +485,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 +502,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

data/lib/tina4/cors.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Tina4
+  module CorsMiddleware
+    class << self
+      def config
+        @config ||= load_config
+      end
+
+      def reset!
+        @config = nil
+      end
+
+      # Handle OPTIONS preflight request, returns a Rack response array
+      def preflight_response(env = {})
+        origin = resolve_origin(env)
+        [
+          204,
+          {
+            "access-control-allow-origin" => origin,
+            "access-control-allow-methods" => config[:methods],
+            "access-control-allow-headers" => config[:headers],
+            "access-control-max-age" => config[:max_age],
+            "access-control-allow-credentials" => config[:credentials]
+          },
+          [""]
+        ]
+      end
+
+      # Apply CORS headers to a response headers hash
+      def apply_headers(response_headers, env = {})
+        origin = resolve_origin(env)
+        response_headers["access-control-allow-origin"] = origin
+        response_headers["access-control-allow-methods"] = config[:methods]
+        response_headers["access-control-allow-headers"] = config[:headers]
+        response_headers["access-control-max-age"] = config[:max_age]
+        response_headers["access-control-allow-credentials"] = config[:credentials] if config[:credentials] == "true"
+        response_headers
+      end
+
+      # Check if a given origin is allowed
+      def origin_allowed?(origin)
+        return true if config[:origins] == "*"
+
+        allowed = config[:origins].split(",").map(&:strip)
+        allowed.include?(origin)
+      end
+
+      private
+
+      def load_config
+        {
+          origins: ENV["TINA4_CORS_ORIGINS"] || "*",
+          methods: ENV["TINA4_CORS_METHODS"] || "GET, POST, PUT, PATCH, DELETE, OPTIONS",
+          headers: ENV["TINA4_CORS_HEADERS"] || "Content-Type, Authorization, Accept",
+          max_age: ENV["TINA4_CORS_MAX_AGE"] || "86400",
+          credentials: ENV["TINA4_CORS_CREDENTIALS"] || "false"
+        }.freeze
+      end
+
+      def resolve_origin(env)
+        request_origin = env["HTTP_ORIGIN"] || env["HTTP_REFERER"]
+
+        if config[:origins] == "*"
+          "*"
+        elsif request_origin && origin_allowed?(request_origin.chomp("/"))
+          request_origin.chomp("/")
+        else
+          config[:origins].split(",").first&.strip || "*"
+        end
+      end
+    end
+  end
+end