synthra 0.1.0

data/lib/synthra/cli/commands/diff.rb

@@ -0,0 +1,227 @@
+# frozen_string_literal: true
+
+module Synthra
+  class CLI
+    module Commands
+      # Diff command - compares schema versions
+      #
+      # @example
+      #   synthra diff schemas/v1/ schemas/v2/
+      #   synthra diff schemas/v1/ schemas/v2/ --breaking-only
+      #
+      class Diff < Base
+        def call
+          path1 = args.shift
+          path2 = args.shift
+
+          unless path1 && path2
+            error "Usage: synthra diff <path1> <path2> [--breaking-only]"
+            return EXIT_PARSE_ERROR
+          end
+
+          registry1 = Registry.new
+          registry2 = Registry.new
+
+          load_path(registry1, path1)
+          load_path(registry2, path2)
+
+          changes = compute_diff(registry1, registry2)
+
+          if options[:breaking_only]
+            display_breaking_changes(changes, path1, path2)
+          else
+            display_full_diff(changes, path1, path2)
+          end
+        end
+
+        private
+
+        # Compute detailed diff between two registries
+        #
+        # @return [Hash] structured diff results
+        #
+        def compute_diff(registry1, registry2)
+          schemas1 = registry1.schemas
+          schemas2 = registry2.schemas
+          all_names = (schemas1.keys + schemas2.keys).uniq.sort
+
+          {
+            added: schemas2.keys - schemas1.keys,
+            removed: schemas1.keys - schemas2.keys,
+            modified: compute_modified(schemas1, schemas2, all_names),
+            breaking: compute_breaking_changes(schemas1, schemas2, all_names)
+          }
+        end
+
+        def compute_modified(schemas1, schemas2, all_names)
+          modified = {}
+          
+          (schemas1.keys & schemas2.keys).each do |name|
+            s1 = schemas1[name]
+            s2 = schemas2[name]
+            changes = compare_schemas(s1, s2)
+            modified[name] = changes if changes.any?
+          end
+
+          modified
+        end
+
+        def compute_breaking_changes(schemas1, schemas2, all_names)
+          breaking = []
+
+          # Removed schemas are breaking
+          (schemas1.keys - schemas2.keys).each do |name|
+            breaking << { schema: name, type: :schema_removed, message: "Schema '#{name}' removed" }
+          end
+
+          # Check field changes
+          (schemas1.keys & schemas2.keys).each do |name|
+            s1 = schemas1[name]
+            s2 = schemas2[name]
+
+            # Removed fields are breaking
+            f1_names = s1.fields.map(&:name)
+            f2_names = s2.fields.map(&:name)
+
+            (f1_names - f2_names).each do |field_name|
+              breaking << {
+                schema: name,
+                type: :field_removed,
+                field: field_name,
+                message: "Field '#{field_name}' removed from '#{name}'"
+              }
+            end
+
+            # Type changes are breaking
+            (f1_names & f2_names).each do |field_name|
+              field1 = s1.field(field_name)
+              field2 = s2.field(field_name)
+
+              if field1.type_name != field2.type_name
+                breaking << {
+                  schema: name,
+                  type: :type_changed,
+                  field: field_name,
+                  from: field1.type_name,
+                  to: field2.type_name,
+                  message: "Field '#{field_name}' type changed: #{field1.type_name} → #{field2.type_name}"
+                }
+              end
+
+              # Required → Optional is not breaking, but Optional → Required is
+              if !field1.optional? && field2.optional?
+                # Not breaking
+              elsif field1.optional? && !field2.optional?
+                breaking << {
+                  schema: name,
+                  type: :required_added,
+                  field: field_name,
+                  message: "Field '#{field_name}' changed from optional to required"
+                }
+              end
+            end
+          end
+
+          breaking
+        end
+
+        def compare_schemas(s1, s2)
+          diff = []
+
+          # Compare versions
+          if s1.version != s2.version
+            diff << "version: #{s1.version || 'nil'} → #{s2.version || 'nil'}"
+          end
+
+          # Compare deprecation
+          if s1.deprecated? != s2.deprecated?
+            diff << "deprecated: #{s1.deprecated?} → #{s2.deprecated?}"
+          end
+
+          # Compare fields
+          f1_names = s1.fields.map(&:name)
+          f2_names = s2.fields.map(&:name)
+
+          (f2_names - f1_names).each { |f| diff << "+ field: #{f}" }
+          (f1_names - f2_names).each { |f| diff << "- field: #{f}" }
+
+          # Compare field types
+          (f1_names & f2_names).each do |name|
+            field1 = s1.field(name)
+            field2 = s2.field(name)
+            if field1.type_name != field2.type_name
+              diff << "~ #{name}: #{field1.type_name} → #{field2.type_name}"
+            end
+          end
+
+          diff
+        end
+
+        def display_breaking_changes(changes, path1, path2)
+          breaking = changes[:breaking]
+
+          if breaking.empty?
+            success "No breaking changes detected"
+            return EXIT_SUCCESS
+          end
+
+          puts "=" * 60
+          puts "BREAKING CHANGES DETECTED"
+          puts "=" * 60
+          puts
+          puts "Comparing: #{path1} → #{path2}"
+          puts
+
+          breaking.each do |change|
+            puts "  ✗ #{change[:message]}"
+          end
+
+          puts
+          error "#{breaking.length} breaking change(s) found"
+          EXIT_PARSE_ERROR
+        end
+
+        def display_full_diff(changes, path1, path2)
+          puts "=" * 60
+          puts "Schema Diff"
+          puts "=" * 60
+          puts "Comparing: #{path1} → #{path2}"
+          puts
+
+          has_diff = false
+
+          # Added schemas
+          changes[:added].each do |name|
+            puts "➕ #{name} (added)"
+            has_diff = true
+          end
+
+          # Removed schemas
+          changes[:removed].each do |name|
+            puts "➖ #{name} (removed)"
+            has_diff = true
+          end
+
+          # Modified schemas
+          changes[:modified].each do |name, diffs|
+            puts "📝 #{name} (modified)"
+            diffs.each { |d| puts "   #{d}" }
+            has_diff = true
+          end
+
+          unless has_diff
+            success "No differences found"
+          end
+
+          # Show breaking changes summary if any
+          if changes[:breaking].any?
+            puts
+            puts "⚠️  Breaking changes: #{changes[:breaking].length}"
+          end
+
+          EXIT_SUCCESS
+        end
+      end
+    end
+  end
+end

data/lib/synthra/cli/commands/docs.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Synthra
+  class CLI
+    module Commands
+      # CLI command for generating schema documentation
+      #
+      # @example Generate docs
+      #   $ synthra docs schemas/ --output docs/
+      #
+      class Docs
+        EXIT_SUCCESS = 0
+        EXIT_ERROR = 1
+
+        def initialize
+          # No args needed for this command
+        end
+
+        def call(schema_dir, options)
+          unless File.directory?(schema_dir)
+            $stderr.puts "✗ Schema directory not found: #{schema_dir}"
+            return EXIT_ERROR
+          end
+
+          output_dir = options[:output] || "docs"
+          title = options[:title] || "Synthra Schema Documentation"
+
+          generate_documentation(schema_dir, output_dir, title)
+        end
+
+        private
+
+        def generate_documentation(schema_dir, output_dir, title)
+          require_relative "../../documentation_generator"
+          
+          puts "📚 Generating documentation..."
+          puts "   Source: #{schema_dir}"
+          puts "   Output: #{output_dir}"
+          puts ""
+
+          # Load schemas
+          registry = Registry.new
+          registry.load_dir(schema_dir)
+
+          if registry.names.empty?
+            $stderr.puts "✗ No schemas found in #{schema_dir}"
+            return EXIT_ERROR
+          end
+
+          # Generate docs
+          generator = DocumentationGenerator.new(registry, title: title)
+          files = generator.generate_html(output_dir)
+
+          puts "✅ Generated #{files.count} documentation files:"
+          files.each { |path| puts "   #{path}" }
+          puts ""
+          puts "   Open #{output_dir}/index.html in your browser"
+
+          EXIT_SUCCESS
+        rescue StandardError => e
+          $stderr.puts "✗ Documentation generation failed: #{e.message}"
+          EXIT_ERROR
+        end
+      end
+    end
+  end
+end

data/lib/synthra/cli/commands/export.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Synthra
+  class CLI
+    module Commands
+      # Export command - exports schemas to various formats
+      #
+      # @example
+      #   synthra export User -d schemas -f typescript -o user.ts
+      #   synthra export --all -d schemas -f graphql -o schema.graphql
+      #
+      class Export < Base
+        def call
+          schema_name = args.shift
+
+          registry = Registry.new
+          load_path(registry, options[:dir], validate: false)
+
+          format = options[:export_format]
+
+          output = if options[:all]
+                     export_all(registry, format)
+                   else
+                     unless schema_name
+                       error "Usage: synthra export <SchemaName> [options]"
+                       error "       synthra export --all [options]"
+                       return EXIT_PARSE_ERROR
+                     end
+                     export_single(registry, schema_name, format)
+                   end
+
+          return EXIT_PARSE_ERROR unless output
+
+          write_output(output, schema_name)
+          EXIT_SUCCESS
+        rescue KeyError
+          error "Unknown schema: #{schema_name}"
+          $stderr.puts "Available schemas: #{registry.names.join(", ")}"
+          EXIT_PARSE_ERROR
+        end
+
+        private
+
+        def export_all(registry, format)
+          case format
+          when "typescript", "ts"
+            Synthra::Export::Typescript.export_all(registry)
+          when "javascript", "js"
+            Synthra::Export::Javascript.export_all(registry)
+          when "python", "py", "pydantic"
+            Synthra::Export::Python.export_all(registry, style: options[:python_style])
+          when "dataclass"
+            Synthra::Export::Python.export_all(registry, style: :dataclass)
+          when "sql", "sql-ddl"
+            Synthra::Export::Sql.export_all(registry, dialect: options[:sql_dialect])
+          when "graphviz", "dot"
+            Synthra::Export::Graphviz.new(nil, registry: registry).export
+          when "graphql"
+            Synthra::Export::Graphql.export_all(registry)
+          else
+            error "Bulk export not supported for format: #{format}"
+            nil
+          end
+        end
+
+        def export_single(registry, schema_name, format)
+          schema = registry.schema(schema_name)
+          export_opts = build_export_options(registry)
+
+          case format
+          # Schema export formats
+          when "json-schema"
+            Synthra::Export::JsonSchema.new(schema, **export_opts).export
+          when "typescript", "ts"
+            Synthra::Export::Typescript.new(schema, **export_opts).export
+          when "javascript", "js"
+            Synthra::Export::Javascript.new(schema, **export_opts).export
+          when "python", "py", "pydantic"
+            Synthra::Export::Python.new(schema, **export_opts.merge(style: options[:python_style])).export
+          when "dataclass"
+            Synthra::Export::Python.new(schema, **export_opts.merge(style: :dataclass)).export
+          when "sql", "sql-ddl"
+            Synthra::Export::Sql.new(schema, registry: registry, dialect: options[:sql_dialect]).export
+          when "graphviz", "dot"
+            Synthra::Export::Graphviz.new(schema, **export_opts).export
+          when "graphql"
+            Synthra::Export::Graphql.new(schema, **export_opts).export
+
+          # Data export formats
+          when "json", "json-data"
+            Synthra::Export::JsonData.new(schema, **export_opts.merge(pretty: options[:pretty])).export
+          when "csv"
+            Synthra::Export::Csv.new(schema, **export_opts).export
+          when "sql-insert", "insert"
+            Synthra::Export::SqlInsert.new(schema, **export_opts.merge(
+              dialect: options[:sql_dialect],
+              batch_insert: options[:batch_insert]
+            )).export
+          when "yaml", "yml"
+            Synthra::Export::YamlData.new(schema, **export_opts).export
+          when "xml"
+            Synthra::Export::XmlData.new(schema, **export_opts.merge(
+              root: options[:root],
+              item: options[:item]
+            )).export
+          else
+            error "Unknown export format: #{format}"
+            nil
+          end
+        end
+
+        def build_export_options(registry)
+          {
+            registry: registry,
+            count: options[:count],
+            seed: options[:seed],
+            mode: options[:mode] || :random
+          }.compact
+        end
+
+        def write_output(output, schema_name)
+          output_path = determine_output_path(schema_name)
+
+          if output_path
+            FileUtils.mkdir_p(File.dirname(output_path)) if File.dirname(output_path) != "."
+            File.write(output_path, output)
+            success "Exported to #{output_path}"
+          else
+            puts output
+          end
+        end
+
+        def determine_output_path(schema_name)
+          if options[:output]
+            options[:output]
+          elsif options[:auto_file]
+            output_dir = options[:output_dir] || "."
+            filename = Synthra::Export.auto_filename(
+              options[:all] ? "all_schemas" : schema_name,
+              options[:export_format]
+            )
+            File.join(output_dir, filename)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/synthra/cli/commands/generate.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Synthra
+  class CLI
+    module Commands
+      # Generate command - generates fake data from a schema
+      #
+      # @example
+      #   synthra generate User --dir schemas --count 10 --pretty
+      #
+      class Generate < Base
+        def call
+          schema_name = args.shift
+
+          unless schema_name
+            error "Usage: synthra generate <SchemaName> [options]"
+            return EXIT_PARSE_ERROR
+          end
+
+          registry = Registry.new
+          load_schemas_from_dir(registry, options[:dir])
+
+          schema = registry.schema(schema_name)
+          generate_output(schema, registry)
+          EXIT_SUCCESS
+        rescue KeyError
+          error "Unknown schema: #{schema_name}"
+          $stderr.puts "Available schemas: #{registry.schemas.keys.join(", ")}"
+          EXIT_PARSE_ERROR
+        end
+
+        private
+
+        def generate_output(schema, registry)
+          gen_options = {
+            seed: options[:seed],
+            mode: options[:mode],
+            registry: registry
+          }.compact
+
+          if options[:format] == :ndjson
+            schema.generate_stream(count: options[:count], **gen_options).each do |record|
+              puts JSON.generate(sanitize_for_json(record))
+            end
+          else
+            records = schema.generate_many(options[:count], **gen_options)
+            output = options[:count] == 1 ? records.first : records
+
+            if options[:pretty]
+              puts JSON.pretty_generate(sanitize_for_json(output))
+            else
+              puts JSON.generate(sanitize_for_json(output))
+            end
+          end
+        end
+
+        def sanitize_for_json(value)
+          case value
+          when Float
+            (value.infinite? || value.nan?) ? nil : value
+          when Hash
+            value.transform_values { |v| sanitize_for_json(v) }
+          when Array
+            value.map { |v| sanitize_for_json(v) }
+          else
+            value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/synthra/cli/commands/import.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Synthra
+  class CLI
+    module Commands
+      # CLI command for importing schemas from external formats
+      #
+      # @example Import from OpenAPI
+      #   $ synthra import openapi.yaml --output schemas/
+      #
+      class Import
+        EXIT_SUCCESS = 0
+        EXIT_ERROR = 1
+
+        def initialize
+          # No args needed for this command
+        end
+
+        def call(input_path, options)
+          unless File.exist?(input_path)
+            $stderr.puts "✗ Input file not found: #{input_path}"
+            return EXIT_ERROR
+          end
+
+          output_dir = options[:output] || "schemas"
+          format = detect_format(input_path)
+
+          case format
+          when :openapi
+            import_openapi(input_path, output_dir)
+          when :json_schema
+            import_json_schema(input_path, output_dir)
+          else
+            $stderr.puts "✗ Unsupported format: #{format}"
+            EXIT_ERROR
+          end
+        end
+
+        private
+
+        def detect_format(path)
+          content = File.read(path)
+          
+          if content.include?("openapi:") || content.include?('"openapi"')
+            :openapi
+          elsif content.include?("swagger:") || content.include?('"swagger"')
+            :openapi
+          elsif content.include?('"$schema"') || content.include?("$schema:")
+            :json_schema
+          else
+            :unknown
+          end
+        end
+
+        def import_openapi(input_path, output_dir)
+          require_relative "../../openapi_importer"
+          
+          puts "📥 Importing from OpenAPI: #{input_path}"
+          
+          importer = OpenAPIImporter.new(input_path)
+          created = importer.import_to_directory(output_dir)
+          
+          puts ""
+          puts "✅ Successfully imported #{created.count} schemas:"
+          created.each { |path| puts "   #{path}" }
+          
+          EXIT_SUCCESS
+        end
+
+        def import_json_schema(input_path, output_dir)
+          # TODO: Implement JSON Schema import
+          puts "📥 JSON Schema import not yet implemented"
+          puts "   Use OpenAPI format for now"
+          
+          EXIT_ERROR
+        end
+      end
+    end
+  end
+end

data/lib/synthra/cli/commands/lint.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Synthra
+  class CLI
+    module Commands
+      # Lint command - checks schemas for semantic errors
+      #
+      # @example
+      #   synthra lint schemas/ --strict
+      #
+      class Lint < Base
+        def call
+          path = args.shift
+
+          unless path
+            error "Usage: synthra lint <path|directory>"
+            return EXIT_PARSE_ERROR
+          end
+
+          registry = Registry.new
+          load_path(registry, path, validate: false)
+
+          errors = registry.validate_paths
+
+          if errors.empty?
+            success "No lint errors found in #{registry.size} schema(s)"
+            if options[:verbose]
+              puts "\nSchemas checked:"
+              registry.names.sort.each { |name| puts "  - #{name}" }
+            end
+            EXIT_SUCCESS
+          else
+            error "Found #{errors.length} lint error(s):\n"
+
+            errors.each_with_index do |err, i|
+              puts "#{i + 1}. #{err.message}"
+              if err.respond_to?(:suggestions) && err.suggestions&.any?
+                puts "   Did you mean: #{err.suggestions.first(3).join(", ")}?"
+              end
+              puts
+            end
+
+            if options[:strict]
+              $stderr.puts "Strict mode: #{errors.length} error(s) treated as failures"
+            end
+
+            EXIT_PARSE_ERROR
+          end
+        end
+      end
+    end
+  end
+end

data/lib/synthra/cli/commands/live.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Synthra
+  class CLI
+    module Commands
+      # CLI command for live preview server
+      #
+      # @example Start live server
+      #   $ synthra live schemas/ --port 4567
+      #
+      class Live
+        DEFAULT_PORT = 4567
+        EXIT_SUCCESS = 0
+        EXIT_ERROR = 1
+
+        def initialize
+          # No args needed for this command
+        end
+
+        def call(schema_dir, options)
+          unless File.directory?(schema_dir)
+            $stderr.puts "✗ Schema directory not found: #{schema_dir}"
+            return EXIT_ERROR
+          end
+
+          port = options[:port] || DEFAULT_PORT
+
+          start_live_server(schema_dir, port)
+        end
+
+        private
+
+        def start_live_server(schema_dir, port)
+          require_relative "../../live_preview"
+          
+          puts "🚀 Starting Synthra Live Preview..."
+          puts ""
+          puts "   Schema directory: #{schema_dir}"
+          puts "   URL: http://localhost:#{port}"
+          puts ""
+          puts "   Press Ctrl+C to stop"
+          puts ""
+
+          LivePreview.start(schema_dir: schema_dir, port: port)
+          
+          EXIT_SUCCESS
+        rescue Errno::EADDRINUSE
+          $stderr.puts "✗ Port #{port} is already in use. Try a different port with --port"
+          EXIT_ERROR
+        rescue StandardError => e
+          $stderr.puts "✗ Failed to start server: #{e.message}"
+          EXIT_ERROR
+        end
+      end
+    end
+  end
+end