flux3_ai_prompt_tools 0.1.0

data/test/cli_test.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require_relative "helper"
+
+class CliTest < Flux3Test
+  def test_help_and_version
+    stdout, stderr, status = run_cli("help")
+    assert_equal 0, status.exitstatus
+    assert_includes stdout, "flux3-prompt"
+    assert_includes stdout, "https://flux3-ai.com/"
+    assert_equal "", stderr
+
+    stdout, _stderr, status = run_cli("version")
+    assert_equal 0, status.exitstatus
+    assert_equal "#{Flux3AiPromptTools::VERSION}\n", stdout
+
+    _stdout, stderr, status = run_cli
+    assert_equal 2, status.exitstatus
+    assert_includes stderr, ""
+    assert_includes stdout_of_no_args, "Usage:"
+  end
+
+  def test_assemble_prints_prompt_and_manifest
+    stdout, stderr, status = run_cli(
+      "assemble",
+      "--preset", "product_still",
+      "--subject", "a matte cream kettle",
+      "--negative", "text",
+      "--negative", "watermark",
+      "--aspect-ratio", "4:5",
+      "--seed", "1204"
+    )
+    assert_equal 0, status.exitstatus, stderr
+    assert_equal "", stderr
+    assert_includes stdout, "a matte cream kettle."
+    assert_includes stdout, "photograph."
+    refute_includes stdout, "watermark"
+
+    stdout, stderr, status = run_cli(
+      "assemble",
+      "--subject", "a matte cream kettle",
+      "--negative", "watermark",
+      "--manifest"
+    )
+    assert_equal 0, status.exitstatus, stderr
+    payload = JSON.parse(stdout)
+    assert_equal "watermark", payload["negative_prompt"]
+    assert_equal "a matte cream kettle.", payload["prompt"]
+    assert_equal true, payload["ok"]
+  end
+
+  def test_assemble_exit_statuses
+    _stdout, stderr, status = run_cli("assemble")
+    assert_equal 1, status.exitstatus
+    assert_includes stderr, "/subject required"
+
+    _stdout, stderr, status = run_cli("assemble", "--subject", "a bowl", "--seed", "nope")
+    assert_equal 2, status.exitstatus
+    assert_match(/seed/, stderr)
+
+    _stdout, stderr, status = run_cli("assemble", "--subject", "a bowl", "--layout", "poem")
+    assert_equal 2, status.exitstatus
+    assert_match(/layout/, stderr)
+
+    _stdout, stderr, status = run_cli("nope")
+    assert_equal 2, status.exitstatus
+    assert_match(/unknown command/, stderr)
+  end
+
+  def test_validate_and_batch_examples
+    stdout, stderr, status = run_cli("validate", File.join(ROOT, "examples", "kettle.json"))
+    assert_equal 0, status.exitstatus, stderr
+    assert_equal "valid: 1 record(s)\n", stdout
+
+    stdout, stderr, status = run_cli("validate", File.join(ROOT, "examples", "batch.jsonl"))
+    assert_equal 0, status.exitstatus, stderr
+    assert_equal "valid: 2 record(s)\n", stdout
+
+    with_tmpdir do |dir|
+      jsonl_path = File.join(dir, "out.jsonl")
+      _stdout, stderr, status = run_cli(
+        "batch", File.join(ROOT, "examples", "batch.jsonl"),
+        "--format", "jsonl",
+        "-o", jsonl_path
+      )
+      assert_equal 0, status.exitstatus, stderr
+      assert_match(/wrote 2 record/, stderr)
+      lines = File.readlines(jsonl_path, chomp: true)
+      assert_equal 2, lines.length
+      first = JSON.parse(lines[0])
+      second = JSON.parse(lines[1])
+      assert_equal "kettle-01", first["id"]
+      assert_equal "natural", first["layout"]
+      assert_includes first["prompt"], "a matte cream ceramic pour-over kettle"
+      refute_includes first["prompt"], "Local reminder"
+      assert_equal "cup-02", second["id"]
+      assert_equal "tagged", second["layout"]
+      assert_equal "3:4", second["parameters"]["aspect_ratio"]
+      refute_includes second["prompt"], "\n"
+
+      json_path = File.join(dir, "out.json")
+      _stdout, stderr, status = run_cli(
+        "batch", File.join(ROOT, "examples", "kettle.json"),
+        "-o", json_path
+      )
+      assert_equal 0, status.exitstatus, stderr
+      document = JSON.parse(File.read(json_path))
+      assert_equal true, document["ok"]
+      assert_equal "kettle-01", document["records"][0]["id"]
+      assert_equal "Local reminder only. This file is not sent anywhere.", document["records"][0]["note"]
+      refute_includes document["records"][0]["prompt"], "Local reminder"
+    end
+  end
+
+  def test_batch_stdin_keep_going_and_strict_writes_nothing
+    stdout, stderr, status = run_cli(
+      "batch", "-",
+      "--input-format", "jsonl",
+      stdin: "{\"subject\":\"a bowl\"}\n{\"subject\":\"a cup\",\"layout\":\"labeled\"}\n"
+    )
+    assert_equal 0, status.exitstatus, stderr
+    rows = stdout.lines.map { |line| JSON.parse(line) }
+    assert_equal %w[item-0001 item-0002], rows.map { |row| row["id"] }
+    assert_includes rows[1]["prompt"], "Subject: a cup"
+
+    with_tmpdir do |dir|
+      source = File.join(dir, "mixed.jsonl")
+      File.write(source, "{\"subject\":\"a bowl\"}\n{\"mood\":\"quiet\"}\n")
+      output = File.join(dir, "mixed-out.jsonl")
+      _stdout, stderr, status = run_cli("batch", source, "--keep-going", "-o", output)
+      assert_equal 1, status.exitstatus
+      assert_match(/1 failed/, stderr)
+      rows = File.readlines(output, chomp: true).map { |line| JSON.parse(line) }
+      assert_equal true, rows[0]["ok"]
+      assert_equal false, rows[1]["ok"]
+      assert_nil rows[1]["prompt"]
+
+      blocked = File.join(dir, "blocked.jsonl")
+      _stdout, stderr, status = run_cli("batch", source, "-o", blocked)
+      assert_equal 1, status.exitstatus
+      assert_includes stderr, "/records/1/subject required"
+      refute File.exist?(blocked)
+    end
+  end
+
+  def test_missing_file_and_schema_presets
+    _stdout, stderr, status = run_cli("validate", "missing-file.json")
+    assert_equal 1, status.exitstatus
+    assert_match(/does not exist/, stderr)
+
+    stdout, stderr, status = run_cli("schema")
+    assert_equal 0, status.exitstatus, stderr
+    schema = JSON.parse(stdout)
+    assert_equal ["subject"], schema["required"]
+    assert_equal false, schema["additionalProperties"]
+    assert_equal Flux3AiPromptTools::Presets::NAMES, schema["properties"]["preset"]["enum"]
+
+    stdout, _stderr, status = run_cli("presets")
+    assert_equal 0, status.exitstatus
+    names = JSON.parse(stdout).map { |preset| preset["name"] }
+    assert_equal Flux3AiPromptTools::Presets::NAMES, names
+  end
+
+  def stdout_of_no_args
+    stdout, _stderr, _status = run_cli
+    stdout
+  end
+end

data/test/helper.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+
+require "minitest/autorun"
+require "flux3_ai_prompt_tools"
+require "json"
+require "open3"
+require "rbconfig"
+require "tmpdir"
+
+class Flux3Test < Minitest::Test
+  ROOT = File.expand_path("..", __dir__)
+
+  def run_cli(*args, stdin: nil)
+    env = { "RUBYLIB" => File.join(ROOT, "lib") }
+    command = [RbConfig.ruby, File.join(ROOT, "bin", "flux3-prompt"), *args.map(&:to_s)]
+    Open3.capture3(env, *command, stdin_data: stdin)
+  end
+
+  def with_tmpdir
+    Dir.mktmpdir("flux3-prompt") do |dir|
+      yield dir
+    end
+  end
+
+  def codes(issues)
+    issues.map(&:code)
+  end
+end

data/test/manifest_test.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require_relative "helper"
+
+class ManifestTest < Flux3Test
+  def test_auto_ids_skip_explicit_ids_and_preserve_order
+    manifest = Flux3AiPromptTools.build_manifest(
+      [
+        { "id" => "item-0001", "subject" => "a bowl" },
+        { "subject" => "a cup" },
+        { "subject" => "a plate", "layout" => "tagged" }
+      ]
+    )
+    assert_equal %w[item-0001 item-0002 item-0003], manifest.records.map(&:id)
+    assert_equal "natural", manifest.records[1].layout
+    assert_equal "tagged", manifest.records[2].layout
+    assert_equal "a plate", manifest.records[2].prompt
+    assert manifest.ok?
+    document = JSON.parse(manifest.to_json_document)
+    assert_equal true, document["ok"]
+    assert_equal 3, document["records"].length
+    lines = manifest.to_jsonl.lines
+    assert_equal 3, lines.length
+    assert_equal "a cup.", JSON.parse(lines[1])["prompt"]
+  end
+
+  def test_duplicate_id_and_duplicate_job
+    error = assert_raises(Flux3AiPromptTools::ValidationError) do
+      Flux3AiPromptTools.build_manifest(
+        [
+          { "id" => "bowl", "subject" => "a bowl", "seed" => 1 },
+          { "id" => "bowl", "subject" => "a cup" },
+          { "subject" => "a bowl", "seed" => 1 },
+          { "subject" => "a bowl", "seed" => 2 }
+        ]
+      )
+    end
+    assert_includes error.issues.map(&:code), "duplicate_id"
+    assert_includes error.issues.map(&:code), "duplicate_job"
+
+    manifest = Flux3AiPromptTools.build_manifest(
+      [
+        { "subject" => "a bowl", "seed" => 1 },
+        { "subject" => "a bowl", "seed" => 1 },
+        { "subject" => "a bowl", "seed" => 2 }
+      ],
+      keep_going: true
+    )
+    assert_equal false, manifest.ok?
+    assert_equal true, manifest.records[0].ok
+    assert_equal false, manifest.records[1].ok
+    assert_nil manifest.records[1].prompt
+    assert_equal "duplicate_job", manifest.records[1].errors.first.code
+    assert_equal true, manifest.records[2].ok
+    assert_equal 2, manifest.records[2].parameters["seed"]
+  end
+
+  def test_keep_going_reports_field_errors_without_dropping_later_records
+    manifest = Flux3AiPromptTools.build_manifest(
+      [
+        { "mood" => "quiet" },
+        { "subject" => "a bowl" }
+      ],
+      keep_going: true
+    )
+    assert_equal false, manifest.records[0].ok
+    assert_equal "required", manifest.records[0].errors.first.code
+    assert_equal "/records/0/subject", manifest.records[0].errors.first.path
+    assert_equal "a bowl.", manifest.records[1].prompt
+  end
+
+  def test_strict_batch_collects_every_record_error
+    error = assert_raises(Flux3AiPromptTools::ValidationError) do
+      Flux3AiPromptTools.build_manifest(
+        [
+          { "subject" => "" },
+          { "subject" => "a bowl", "aspect_ratio" => "wide" }
+        ]
+      )
+    end
+    assert_equal ["/records/0/subject", "/records/1/aspect_ratio"], error.issues.map(&:path)
+  end
+
+  def test_length_errors_are_prefixed_in_a_batch
+    error = assert_raises(Flux3AiPromptTools::ValidationError) do
+      Flux3AiPromptTools.build_manifest(
+        [{ "subject" => "a bowl" }],
+        limits: Flux3AiPromptTools::Limits.new(max_prompt_chars: 3)
+      )
+    end
+    assert_equal "/records/0/prompt", error.issues.first.path
+  end
+
+  def test_empty_and_oversized_batches
+    assert_raises(Flux3AiPromptTools::InputError) do
+      Flux3AiPromptTools.build_manifest([])
+    end
+    assert_raises(Flux3AiPromptTools::InputError) do
+      Flux3AiPromptTools.build_manifest(
+        [{ "subject" => "a bowl" }, { "subject" => "a cup" }],
+        limits: Flux3AiPromptTools::Limits.new(max_records: 1)
+      )
+    end
+  end
+
+  def test_bad_layout_argument
+    error = assert_raises(ArgumentError) do
+      Flux3AiPromptTools.build_manifest([{ "subject" => "a bowl" }], layout: "poem")
+    end
+    assert_match(/layout/, error.message)
+  end
+end

data/test/packaging_test.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "English"
+require_relative "helper"
+
+class PackagingTest < Flux3Test
+  def test_gemspec_metadata_and_packaged_source
+    spec = Gem::Specification.load(File.join(ROOT, "flux3_ai_prompt_tools.gemspec"))
+    assert_equal "flux3_ai_prompt_tools", spec.name
+    assert_equal Flux3AiPromptTools::VERSION, spec.version.to_s
+    assert_equal ["Andy Wang"], spec.authors
+    assert_nil spec.email
+    assert_equal "https://flux3-ai.com/", spec.homepage
+    assert_equal "https://flux3-ai.com/", spec.metadata["homepage_uri"]
+    assert_equal "MIT", spec.license
+    assert_equal "https://rubygems.org", spec.metadata["allowed_push_host"]
+    refute spec.metadata.key?("rubygems_mfa_required")
+    assert_nil spec.metadata["rubygems_mfa_required"]
+    assert_nil spec.metadata["source_code_uri"]
+    assert_empty spec.runtime_dependencies
+    assert_equal Gem::Requirement.new(">= 3.1.0"), spec.required_ruby_version
+    %w[
+      lib/flux3_ai_prompt_tools.rb
+      bin/flux3-prompt
+      README.md
+      LICENSE
+      CHANGELOG.md
+      examples/kettle.json
+      examples/batch.jsonl
+      test/validator_test.rb
+      test/cli_test.rb
+      flux3_ai_prompt_tools.gemspec
+    ].each do |path|
+      assert_includes spec.files, path
+    end
+    assert_operator spec.summary.length, :<=, 144
+    refute_match(/@/, spec.summary)
+    refute_match(/@/, spec.description)
+  end
+
+  def test_readme_describes_real_behavior_and_limits
+    readme = File.read(File.join(ROOT, "README.md"))
+    words = readme.scan(/[A-Za-z0-9]+(?:[-'][A-Za-z0-9]+)*/)
+    assert_operator words.length, :>=, 200
+    assert_includes readme, "https://flux3-ai.com/"
+    assert_includes readme, "does not generate images"
+    assert_includes readme, "not a Black Forest Labs product"
+    assert_includes readme, "flux_3_org"
+    assert_includes readme, "## Limitations"
+    assert_includes readme, "rake test"
+    assert_includes readme, "gem install --user-install flux3_ai_prompt_tools-0.1.0.gem"
+  end
+
+  def test_library_and_executable_do_not_reference_network_clients
+    roots = [File.join(ROOT, "lib"), File.join(ROOT, "bin")]
+    forbidden = %w[Net::HTTP OpenURI TCPSocket UDPSocket Resolv net/http open-uri socket telemetry api_key]
+    offenders = []
+    roots.each do |root|
+      Dir.glob(File.join(root, "**/*")).each do |path|
+        next unless File.file?(path)
+
+        text = File.read(path)
+        forbidden.each do |token|
+          offenders << "#{path} contains #{token}" if text.include?(token)
+        end
+      end
+    end
+    assert_empty offenders
+  end
+
+  def test_examples_round_trip_through_the_library
+    kettle = Flux3AiPromptTools.load_file(File.join(ROOT, "examples", "kettle.json"))
+    result = Flux3AiPromptTools.assemble(kettle.fetch(0))
+    assert_equal "kettle-01", result.id
+    assert_includes result.prompt, "editorial product photography style"
+    refute_includes result.prompt, "Local reminder"
+    assert_equal ["text", "watermark", "extra handle"], result.negative_prompt.split(", ")
+
+    batch = Flux3AiPromptTools.load_file(File.join(ROOT, "examples", "batch.jsonl"))
+    manifest = Flux3AiPromptTools.build_manifest(batch)
+    assert_equal 2, manifest.records.length
+    assert manifest.ok?
+  end
+end

data/test/reader_test.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require_relative "helper"
+
+class ReaderTest < Flux3Test
+  def test_json_object_array_jsonl_and_bom
+    object = Flux3AiPromptTools::Reader.load('{"subject":"a bowl"}', format: "json")
+    assert_equal [{ "subject" => "a bowl" }], object
+
+    array = Flux3AiPromptTools::Reader.load('[{"subject":"a bowl"},{"subject":"a cup"}]', format: "auto")
+    assert_equal 2, array.length
+
+    jsonl = Flux3AiPromptTools::Reader.load("\n{\"subject\":\"a bowl\"}\n\n{\"subject\":\"a cup\"}\n", format: "jsonl")
+    assert_equal %w[a\ bowl a\ cup], jsonl.map { |row| row["subject"] }
+
+    bom = Flux3AiPromptTools::Reader.load("\uFEFF{\"subject\":\"a bowl\"}", format: "auto")
+    assert_equal "a bowl", bom.first["subject"]
+  end
+
+  def test_jsonl_reports_the_line_number
+    error = assert_raises(Flux3AiPromptTools::InputError) do
+      Flux3AiPromptTools::Reader.load("{\"subject\":\"ok\"}\nnot-json\n", format: "jsonl", filename: "batch.jsonl")
+    end
+    assert_equal 2, error.line
+    assert_match(/batch.jsonl:2/, error.message)
+  end
+
+  def test_rejects_non_objects_empty_input_and_oversize_files
+    assert_raises(Flux3AiPromptTools::InputError) do
+      Flux3AiPromptTools::Reader.load("[]", format: "json")
+    end
+    assert_raises(Flux3AiPromptTools::InputError) do
+      Flux3AiPromptTools::Reader.load("[1]", format: "json")
+    end
+    assert_raises(Flux3AiPromptTools::InputError) do
+      Flux3AiPromptTools::Reader.load("   ", format: "auto")
+    end
+
+    with_tmpdir do |dir|
+      path = File.join(dir, "too-big.json")
+      File.binwrite(path, "{\"subject\":\"a bowl\"}")
+      error = assert_raises(Flux3AiPromptTools::InputError) do
+        Flux3AiPromptTools::Reader.load_file(
+          path,
+          limits: Flux3AiPromptTools::Limits.new(max_input_bytes: 4)
+        )
+      end
+      assert_match(/bytes/, error.message)
+
+      missing = assert_raises(Flux3AiPromptTools::InputError) do
+        Flux3AiPromptTools::Reader.load_file(File.join(dir, "missing.json"))
+      end
+      assert_match(/does not exist/, missing.message)
+
+      binary = File.join(dir, "bad.json")
+      File.binwrite(binary, "\xff\xfe")
+      assert_raises(Flux3AiPromptTools::InputError) do
+        Flux3AiPromptTools::Reader.load_file(binary)
+      end
+    end
+  end
+
+  def test_extension_selects_the_reader
+    with_tmpdir do |dir|
+      path = File.join(dir, "rows.jsonl")
+      File.write(path, "{\"subject\":\"a bowl\"}\n{\"subject\":\"a cup\"}\n")
+      rows = Flux3AiPromptTools.load_file(path)
+      assert_equal 2, rows.length
+    end
+  end
+end

data/test/validator_test.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require_relative "helper"
+
+class ValidatorTest < Flux3Test
+  def test_subject_is_required_and_symbol_keys_work
+    issues = Flux3AiPromptTools.validate({ style: "quiet" })
+    assert_equal ["required"], codes(issues)
+    assert_equal "/subject", issues.first.path
+
+    result = Flux3AiPromptTools.assemble({ subject: "  a red bowl  " })
+    assert_equal "a red bowl.", result.prompt
+  end
+
+  def test_blank_optional_string_is_an_error
+    issues = Flux3AiPromptTools.validate({ "subject" => "a bowl", "mood" => "   " })
+    assert_equal ["blank"], codes(issues)
+    assert_equal "/mood", issues.first.path
+  end
+
+  def test_control_characters_and_line_separators_are_rejected
+    ["a\nbowl", "a\u0000bowl", "a\u007Fbowl", "a\u2028bowl", "a\u2029bowl"].each do |subject|
+      issues = Flux3AiPromptTools.validate({ "subject" => subject })
+      assert_equal ["control_character"], codes(issues), subject.inspect
+    end
+  end
+
+  def test_invalid_utf8_is_rejected
+    subject = "a bowl".b
+    subject.setbyte(0, 0xFF)
+    issues = Flux3AiPromptTools.validate({ "subject" => subject })
+    assert_equal ["encoding"], codes(issues)
+  end
+
+  def test_unicode_subject_is_measured_in_characters
+    subject = "一只红碗"
+    result = Flux3AiPromptTools.assemble({ "subject" => subject })
+    assert_equal "一只红碗.", result.prompt
+    assert_equal subject.length + 1, result.counts["prompt_chars"]
+  end
+
+  def test_string_length_limit
+    issues = Flux3AiPromptTools.validate({ "subject" => "a" * 401 })
+    assert_equal ["too_long"], codes(issues)
+  end
+
+  def test_unknown_and_duplicate_fields
+    issues = Flux3AiPromptTools.validate({ "subject" => "a bowl", "model" => "none", :subject => "other" })
+    assert_includes codes(issues), "unknown_field"
+    assert_includes codes(issues), "duplicate_field"
+    refute_includes JSON.generate(issues.map(&:to_h)), "endpoint"
+  end
+
+  def test_null_clears_a_preset_field
+    result = Flux3AiPromptTools.assemble(
+      { "preset" => "product_still", "subject" => "a bowl", "lighting" => nil }
+    )
+    refute_includes result.prompt, "Lighting:"
+    assert_includes result.prompt, "photograph."
+  end
+
+  def test_unknown_preset_and_layout
+    issues = Flux3AiPromptTools.validate({ "subject" => "a bowl", "preset" => "cinematic", "layout" => "poem" })
+    assert_equal %w[unknown_preset unknown_layout], codes(issues)
+  end
+
+  def test_detail_weights_and_bad_detail_shapes
+    result = Flux3AiPromptTools.assemble(
+      {
+        "subject" => "a bowl",
+        "details" => ["speckled glaze", { "text" => "wide rim", "weight" => 1.2 }]
+      }
+    )
+    assert_includes result.prompt, "speckled glaze"
+    assert_includes result.prompt, "wide rim (emphasis 1.2)"
+
+    issues = Flux3AiPromptTools.validate(
+      {
+        "subject" => "a bowl",
+        "details" => [{ "text" => "rim", "weight" => 2.01, "boost" => true }, ""]
+      }
+    )
+    assert_includes codes(issues), "range"
+    assert_includes codes(issues), "unknown_field"
+    assert_includes codes(issues), "blank"
+  end
+
+  def test_numeric_metadata_bounds
+    ok = Flux3AiPromptTools.assemble(
+      { "subject" => "a bowl", "seed" => 0, "steps" => 150, "guidance" => 3.5, "aspect_ratio" => "64:1" }
+    )
+    assert_equal 0, ok.parameters["seed"]
+    assert_equal 150, ok.parameters["steps"]
+    assert_in_delta 3.5, ok.parameters["guidance"], 0.0001
+    assert_equal "64:1", ok.parameters["aspect_ratio"]
+
+    bad = Flux3AiPromptTools.validate(
+      {
+        "subject" => "a bowl",
+        "seed" => 1.0,
+        "steps" => 0,
+        "guidance" => 30.01,
+        "aspect_ratio" => "65:1"
+      }
+    )
+    assert_equal %w[range type range range], codes(bad)
+  end
+
+  def test_seed_above_the_safe_json_integer_is_rejected
+    issues = Flux3AiPromptTools.validate({ "subject" => "a bowl", "seed" => Flux3AiPromptTools::Limits::MAX_SEED + 1 })
+    assert_equal ["range"], codes(issues)
+
+    result = Flux3AiPromptTools.assemble({ "subject" => "a bowl", "seed" => Flux3AiPromptTools::Limits::MAX_SEED })
+    assert_equal Flux3AiPromptTools::Limits::MAX_SEED, result.parameters["seed"]
+  end
+
+  def test_internal_spaces_are_preserved_and_terminal_punctuation_is_kept
+    result = Flux3AiPromptTools.assemble({ "subject" => "Watch the rim." })
+    assert_equal "Watch the rim.", result.prompt
+    spaced = Flux3AiPromptTools.assemble({ "subject" => "a  red bowl" })
+    assert_equal "a  red bowl.", spaced.prompt
+  end
+
+  def test_note_is_stored_and_not_rendered
+    result = Flux3AiPromptTools.assemble({ "subject" => "a bowl", "note" => "private reminder" })
+    assert_equal "private reminder", result.note
+    refute_includes result.prompt, "private"
+    refute_includes result.negative_prompt, "private"
+  end
+
+  def test_non_hash_record
+    issues = Flux3AiPromptTools.validate(["a bowl"])
+    assert_equal ["type"], codes(issues)
+  end
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification
+name: flux3_ai_prompt_tools
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Andy Wang
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-11-08 00:00:00.000000000 Z
+dependencies: []
+description: |
+  Offline Ruby library and command-line tool that validates structured prompt
+  specifications and assembles text-to-image prompts into JSON and JSONL
+  manifests. It does not generate images, call a model API, or send data
+  over the network. It is an independent utility by Andy Wang and is not a
+  Black Forest Labs product, an official FLUX client, or the flux_3_org gem.
+email:
+executables:
+- flux3-prompt
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- Rakefile
+- bin/flux3-prompt
+- examples/batch.jsonl
+- examples/kettle.json
+- flux3_ai_prompt_tools.gemspec
+- lib/flux3_ai_prompt_tools.rb
+- lib/flux3_ai_prompt_tools/assembler.rb
+- lib/flux3_ai_prompt_tools/cli.rb
+- lib/flux3_ai_prompt_tools/errors.rb
+- lib/flux3_ai_prompt_tools/fields.rb
+- lib/flux3_ai_prompt_tools/layouts.rb
+- lib/flux3_ai_prompt_tools/limits.rb
+- lib/flux3_ai_prompt_tools/manifest.rb
+- lib/flux3_ai_prompt_tools/numbers.rb
+- lib/flux3_ai_prompt_tools/presets.rb
+- lib/flux3_ai_prompt_tools/reader.rb
+- lib/flux3_ai_prompt_tools/schema.rb
+- lib/flux3_ai_prompt_tools/specification.rb
+- lib/flux3_ai_prompt_tools/validator.rb
+- lib/flux3_ai_prompt_tools/version.rb
+- test/assembler_test.rb
+- test/cli_test.rb
+- test/helper.rb
+- test/manifest_test.rb
+- test/packaging_test.rb
+- test/reader_test.rb
+- test/validator_test.rb
+homepage: https://flux3-ai.com/
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://flux3-ai.com/
+  allowed_push_host: https://rubygems.org
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.20
+signing_key:
+specification_version: 4
+summary: Validate structured inputs and assemble offline text-to-image prompt manifests.
+test_files: []