neon_sakura 0.1.4

data/scripts/license-check.rb

@@ -0,0 +1,587 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# License checking script for commercial Ruby projects
+# Checks gem licenses against a whitelist of commercial-friendly licenses
+
+require 'json'
+require 'bundler'
+require 'net/http'
+require 'uri'
+require 'open3'
+
+class LicenseChecker
+  # Commercial-friendly license whitelist
+  APPROVED_LICENSES = Set.new([
+                                'MIT',
+                                'Apache-2.0',
+                                'Apache 2.0',
+                                'Apache License 2.0',
+                                'Apache Software License',
+                                'Apache',
+                                'HPND',
+                                'BSD-2-Clause',
+                                'BSD-3-Clause',
+                                'BSD',
+                                'ISC',
+                                'CC0-1.0',
+                                'Unlicense',
+                                'Public Domain',
+                                'Ruby',
+                                'Ruby License',
+                                'Simplified BSD',
+                                'Modified BSD',
+                                'New BSD',
+                                'BSD-2-Clause-Patent',
+                                'BSD-3-Clause-Clear',
+                                'CC-BY-3.0',
+                                'CC-BY-4.0',
+                                'WTFPL',
+                                'Zlib',
+                                'PostgreSQL',
+                                'OpenSSL',
+                                'SSLeay',
+                                'curl',
+                                'libpng',
+                                'libjpeg',
+                                'FTL',
+                                'Bzip2',
+                                'zlib/libpng',
+                                'MIT-0',
+                                'MPL-2.0',
+                                'Mozilla Public License 2.0',
+                                'EPL-1.0',
+                                'EPL-2.0',
+                                'Eclipse Public License 1.0',
+                                'Eclipse Public License 2.0',
+                                'CDDL-1.0',
+                                'CDDL-1.1',
+                                'Common Development and Distribution License 1.0',
+                                'Common Development and Distribution License 1.1',
+                                'X11',
+                                'MIT/X11',
+                                'Artistic-2.0',
+                                'Artistic License 2.0',
+                                'Unicode-TOU',
+                                'Unicode License Agreement - Data Files and Software',
+                                'W3C',
+                                'W3C Software Notice and License',
+                                'JSON',
+                                'same as ruby',
+                                'same as ruby\'s',
+                                'Ruby\'s',
+                                'same as Ruby\'s',
+                                'Ruby License',
+                                'same as Ruby',
+                                'Ruby license',
+                                'same as ruby license',
+                                'Ruby License/GPL',
+                                'Ruby/GPL',
+                                'GPL-2.0+ OR Ruby',
+                                'GPL-3.0+ OR Ruby',
+                                'BSD-2-Clause OR Ruby',
+                                'BSD-3-Clause OR Ruby',
+                                'MIT OR Ruby',
+                                'Apache-2.0 OR Ruby',
+                                'Dual licensed under Ruby or GPLv2+',
+                                'Dual licensed under Ruby or GPLv3+',
+                                'Dual MIT/GPL',
+                                'MIT OR GPL-2.0',
+                                'MIT OR GPL-3.0',
+                                'Apache-2.0 OR MIT',
+                                'BSD-2-Clause OR MIT',
+                                'BSD-3-Clause OR MIT',
+                                'GPL-2.0+ OR MIT',
+                                'GPL-3.0+ OR MIT',
+                                'LGPL-2.1',
+                                'LGPL-2.1+',
+                                'LGPL-3.0',
+                                'LGPL-3.0+',
+                                'Lesser General Public License 2.1',
+                                'Lesser General Public License 3.0',
+                                'GNU Lesser General Public License v2.1',
+                                'GNU Lesser General Public License v3.0',
+                                'GPL-2.0+ OR LGPL-2.1+',
+                                'GPL-3.0+ OR LGPL-3.0+',
+                                'Nonstandard',
+                                'none',
+                                'unknown',
+                                'proprietary',
+                                'Brakeman Public Use License'
+                              ]).freeze
+
+  # Known problematic licenses that require override
+  PROBLEMATIC_LICENSES = Set.new([
+                                   'GPL-2.0',
+                                   'GPL-3.0',
+                                   'GPL-2.0+',
+                                   'GPL-3.0+',
+                                   'GPLv2',
+                                   'GPLv3',
+                                   'GNU GPL v2',
+                                   'GNU GPL v3',
+                                   'GNU General Public License v2.0',
+                                   'GNU General Public License v3.0',
+                                   'AGPL-3.0',
+                                   'AGPL-3.0+',
+                                   'GNU Affero General Public License v3.0',
+                                   'CC-BY-SA-3.0',
+                                   'CC-BY-SA-4.0',
+                                   'Creative Commons Attribution-ShareAlike 3.0',
+                                   'Creative Commons Attribution-ShareAlike 4.0',
+                                   'EUPL-1.1',
+                                   'EUPL-1.2',
+                                   'European Union Public License 1.1',
+                                   'European Union Public License 1.2',
+                                   'CPAL-1.0',
+                                   'Common Public Attribution License 1.0',
+                                   'OSL-3.0',
+                                   'Open Software License 3.0',
+                                   'QPL-1.0',
+                                   'Q Public License 1.0',
+                                   'Sleepycat',
+                                   'Berkeley Database License',
+                                   'CPOL-1.02',
+                                   'Code Project Open License 1.02'
+                                 ]).freeze
+
+  def initialize
+    @override_file = 'config/license_overrides.yml'
+    @overrides = load_overrides
+    @exit_code = 0
+    @python_requirements = find_python_requirements
+    @ml_models = find_ml_models
+  end
+
+  def check_licenses
+    puts '🔍 Checking licenses for commercial compatibility...'
+    puts '📦 Scanning Ruby gems...'
+
+    problematic_gems = []
+    unknown_gems = []
+
+    # Get all gems and their specifications
+    Bundler.load.specs.each do |spec|
+      next if spec.name == 'bundler' # Skip bundler itself
+
+      licenses = get_gem_licenses(spec)
+
+      # Check if gem is overridden (for both licensed and unlicensed gems)
+      if @overrides.dig('approved_gems', spec.name)
+        puts "✅ #{spec.name} (#{spec.version}) - OVERRIDE: #{@overrides['approved_gems'][spec.name]}"
+        next
+      end
+
+      if licenses.empty?
+        unknown_gems << { name: spec.name, version: spec.version.to_s, type: 'ruby' }
+        next
+      end
+
+      # Check licenses
+      approved = licenses.any? { |license| license_approved?(license) }
+
+      if approved
+        puts "✅ 💎 #{spec.name} (#{spec.version}) - #{licenses.join(', ')}"
+      else
+        problematic_gems << {
+          name: spec.name,
+          version: spec.version.to_s,
+          type: 'ruby',
+          licenses: licenses,
+          problematic: licenses.any? { |license| PROBLEMATIC_LICENSES.include?(license) }
+        }
+      end
+    end
+
+    # Check Python dependencies
+    puts "\n🐍 Scanning Python dependencies..."
+    python_results = check_python_dependencies
+
+    # Check ML models
+    puts "\n🤖 Scanning ML models..."
+    model_results = check_ml_models
+
+    # Check Docker containers
+    puts "\n🐳 Scanning Docker containers..."
+    container_results = check_docker_containers
+
+    # Combine all results
+    all_problematic = problematic_gems + python_results[:problematic] + model_results[:problematic] + container_results[:problematic]
+    all_unknown = unknown_gems + python_results[:unknown] + model_results[:unknown] + container_results[:unknown]
+
+    # Report results
+    if all_problematic.any?
+      puts "\n❌ PROBLEMATIC LICENSES FOUND:"
+      all_problematic.each do |item|
+        severity = item[:problematic] ? '🚨 BLOCKED' : '⚠️  REVIEW'
+        type_icon = get_type_icon(item[:type])
+        puts "  #{severity} #{type_icon} #{item[:name]} (#{item[:version]}) - #{item[:licenses].join(', ')}"
+      end
+
+      puts "\n💡 To approve items, add them to #{@override_file}:"
+      puts 'approved_gems:'
+      all_problematic.each do |item|
+        puts "  #{item[:name]}: \"Commercial license approved - [reason]\""
+      end
+
+      @exit_code = 1
+    end
+
+    if all_unknown.any?
+      puts "\n⚠️  UNKNOWN LICENSES (please investigate):"
+      all_unknown.each do |item|
+        type_icon = get_type_icon(item[:type])
+        puts "  #{type_icon} #{item[:name]} (#{item[:version]}) - No license information"
+      end
+
+      puts "\n💡 To approve items with unknown licenses, add them to #{@override_file}:"
+      puts 'approved_gems:'
+      all_unknown.each do |item|
+        puts "  #{item[:name]}: \"License verified manually - [details]\""
+      end
+
+      @exit_code = 1
+    end
+
+    if @exit_code.zero?
+      puts "\n✅ All licenses are commercial-friendly!"
+      puts '📊 Summary:'
+      puts "  💎 Ruby gems: #{Bundler.load.specs.count - 1} checked"
+      puts "  🐍 Python packages: #{python_results[:total]} checked"
+      puts "  🤖 ML models: #{model_results[:total]} checked"
+      puts "  🐳 Docker containers: #{container_results[:total]} checked"
+    else
+      puts "\n❌ License check failed. Please review the items above."
+    end
+
+    exit @exit_code
+  end
+
+  private
+
+  def find_python_requirements
+    # Use the unified requirements.txt at project root
+    # requirements_files << 'requirements.txt' if File.exist?('requirements.txt')
+    # requirements_files
+
+    [ 'docker/donut-service/requirements.txt' ]
+  end
+
+  def find_ml_models
+    models = []
+    # Search for model references in Python files
+    Dir.glob('**/*.py').each do |file|
+      content = File.read(file)
+      # Look for Hugging Face model references
+      content.scan(%r{["']([\w-]+/[\w-]+)["']}) do |match|
+        model_name = match[0]
+        models << { name: model_name, file: file } if model_name.include?('/') && !model_name.include?('http')
+      end
+    end
+    models.uniq
+  end
+
+  def check_python_dependencies
+    problematic = []
+    unknown = []
+    total = 0
+
+    @python_requirements.each do |req_file|
+      next unless File.exist?(req_file)
+
+      File.readlines(req_file).each do |line|
+        line.strip!
+        next if line.empty? || line.start_with?('#')
+
+        # Parse package name and version
+        package_name = line.split(/[=<>!]/)[0].strip
+        # Handle uvicorn[standard] style package names
+        package_name = package_name.split('[')[0] if package_name.include?('[')
+        total += 1
+
+        # Check if overridden
+        if @overrides.dig('approved_gems', package_name)
+          puts "✅ 🐍 #{package_name} - OVERRIDE: #{@overrides['approved_gems'][package_name]}"
+          next
+        end
+
+        # Get license from PyPI
+        license_info = get_pypi_license(package_name)
+
+        if license_info.nil?
+          unknown << {
+            name: package_name,
+            version: line.split('==')[1] || 'latest',
+            type: 'python',
+            licenses: []
+          }
+        elsif license_approved?(license_info)
+          puts "✅ 🐍 #{package_name} - #{license_info}"
+        else
+          problematic << {
+            name: package_name,
+            version: line.split('==')[1] || 'latest',
+            type: 'python',
+            licenses: [ license_info ],
+            problematic: PROBLEMATIC_LICENSES.include?(license_info)
+          }
+        end
+      end
+    end
+
+    { problematic: problematic, unknown: unknown, total: total }
+  end
+
+  def check_ml_models
+    problematic = []
+    unknown = []
+    total = 0
+
+    @ml_models.each do |model_info|
+      total += 1
+      model_name = model_info[:name]
+
+      # Check if overridden
+      if @overrides.dig('approved_gems', model_name)
+        puts "✅ 🤖 #{model_name} - OVERRIDE: #{@overrides['approved_gems'][model_name]}"
+        next
+      end
+
+      # Get license from Hugging Face API
+      license_info = get_huggingface_license(model_name)
+
+      if license_info.nil?
+        unknown << {
+          name: model_name,
+          version: 'latest',
+          type: 'ml_model',
+          licenses: []
+        }
+      elsif license_approved?(license_info)
+        puts "✅ 🤖 #{model_name} - #{license_info}"
+      else
+        problematic << {
+          name: model_name,
+          version: 'latest',
+          type: 'ml_model',
+          licenses: [ license_info ],
+          problematic: PROBLEMATIC_LICENSES.include?(license_info)
+        }
+      end
+    end
+
+    { problematic: problematic, unknown: unknown, total: total }
+  end
+
+  def check_docker_containers
+    problematic = []
+    unknown = []
+    total = 0
+
+    # Check Dockerfiles for base images and their licenses
+    dockerfiles = Dir.glob('**/Dockerfile*')
+
+    dockerfiles.each do |dockerfile|
+      content = File.read(dockerfile)
+
+      # Extract FROM statements
+      content.scan(/^FROM\s+([^\s]+)/) do |match|
+        image_name = match[0]
+        next if image_name == 'scratch' || image_name.start_with?('$') || image_name == 'base'
+
+        total += 1
+
+        # Check if overridden
+        if @overrides.dig('approved_gems', image_name)
+          puts "✅ 🐳 #{image_name} - OVERRIDE: #{@overrides['approved_gems'][image_name]}"
+          next
+        end
+
+        # For common base images, assume they're fine
+        if image_name.match?(/(ubuntu|debian|alpine|python|node|ruby):/)
+          puts "✅ 🐳 #{image_name} - Standard base image (assumed MIT/Apache compatible)"
+        else
+          unknown << {
+            name: image_name,
+            version: 'latest',
+            type: 'docker',
+            licenses: []
+          }
+        end
+      end
+    end
+
+    { problematic: problematic, unknown: unknown, total: total }
+  end
+
+  def get_pypi_license(package_name)
+    uri = URI("https://pypi.org/pypi/#{package_name}/json")
+    response = Net::HTTP.get_response(uri)
+
+    return nil unless response.code == '200'
+
+    data = JSON.parse(response.body)
+    license_info = data.dig('info', 'license')
+
+    # Try classifiers if license field is empty
+    if license_info.nil? || license_info.empty?
+      classifiers = data.dig('info', 'classifiers') || []
+      license_classifiers = classifiers.select { |c| c.start_with?('License ::') }
+
+      unless license_classifiers.empty?
+        # Extract license from classifier like "License :: OSI Approved :: MIT License"
+        license_info = license_classifiers.first.split(' :: ').last
+      end
+    end
+
+    normalize_license(license_info)
+  rescue StandardError => e
+    puts "⚠️  Error fetching PyPI info for #{package_name}: #{e.message}"
+    nil
+  end
+
+  def get_huggingface_license(model_name)
+    uri = URI("https://huggingface.co/api/models/#{model_name}")
+    response = Net::HTTP.get_response(uri)
+
+    return nil unless response.code == '200'
+
+    data = JSON.parse(response.body)
+    license_info = data['license']
+
+    normalize_license(license_info)
+  rescue StandardError => e
+    puts "⚠️  Error fetching Hugging Face info for #{model_name}: #{e.message}"
+    nil
+  end
+
+  def get_type_icon(type)
+    case type
+    when 'ruby' then '💎'
+    when 'python' then '🐍'
+    when 'ml_model' then '🤖'
+    when 'docker' then '🐳'
+    else '📦'
+    end
+  end
+
+  def get_gem_licenses(spec)
+    licenses = []
+
+    # Try spec.licenses first (array)
+    if spec.respond_to?(:licenses) && spec.licenses.any?
+      licenses = spec.licenses
+    elsif spec.respond_to?(:license) && spec.license
+      licenses = [ spec.license ]
+    end
+
+    # Normalize license names
+    licenses.map { |license| normalize_license(license) }.compact.uniq
+  end
+
+  def normalize_license(license)
+    return nil if license.nil? || license.strip.empty?
+
+    normalized = license.strip
+
+    # If license text is very long (likely full license text), try to extract just the license name
+    if normalized.length > 200
+      # Look for common license identifiers in long text
+      case normalized.downcase
+      when /bsd.*3.*clause/i
+        return 'BSD-3-Clause'
+      when /bsd.*2.*clause/i
+        return 'BSD-2-Clause'
+      when /bsd/i
+        return 'BSD'
+      when /mit/i
+        return 'MIT'
+      when /apache.*2/i
+        return 'Apache-2.0'
+      when /apache/i
+        return 'Apache'
+      when /gpl.*3/i
+        return 'GPL-3.0'
+      when /gpl.*2/i
+        return 'GPL-2.0'
+      when /lgpl.*3/i
+        return 'LGPL-3.0'
+      when /lgpl.*2/i
+        return 'LGPL-2.1'
+      when /mozilla.*public.*license/i
+        return 'MPL-2.0'
+      else
+        # Truncate very long license text and add indicator
+        return "#{normalized[0..100]}... [truncated - full license text]"
+      end
+    end
+
+    # Common normalizations for shorter license names
+    case normalized.downcase
+    when 'mit license', 'mit-license', 'mit (http://opensource.org/licenses/mit-license.php)'
+      'MIT'
+    when 'apache license, version 2.0', 'apache license 2.0', 'apache-2.0 license', 'apache 2.0 license'
+      'Apache-2.0'
+    when 'bsd license', 'bsd-style', 'bsd style'
+      'BSD'
+    when 'bsd 3-clause license', 'bsd-3-clause'
+      'BSD-3-Clause'
+    when 'bsd 2-clause license', 'bsd-2-clause'
+      'BSD-2-Clause'
+    when 'gpl-2.0', 'gpl v2', 'gpl version 2', 'gnu gpl v2'
+      'GPL-2.0'
+    when 'gpl-3.0', 'gpl v3', 'gpl version 3', 'gnu gpl v3'
+      'GPL-3.0'
+    when 'lgpl-2.1', 'lgpl v2.1', 'lgpl version 2.1', 'gnu lgpl v2.1'
+      'LGPL-2.1'
+    when 'lgpl-3.0', 'lgpl v3', 'lgpl version 3', 'gnu lgpl v3'
+      'LGPL-3.0'
+    when 'mozilla public license 2.0'
+      'MPL-2.0'
+    when 'eclipse public license 1.0'
+      'EPL-1.0'
+    when 'eclipse public license 2.0'
+      'EPL-2.0'
+    when 'artistic license 2.0'
+      'Artistic-2.0'
+    when 'public domain'
+      'Public Domain'
+    when 'unlicense'
+      'Unlicense'
+    when 'cc0', 'cc0 1.0', 'cc0-1.0 universal'
+      'CC0-1.0'
+    when 'ruby license', 'ruby\'s license', 'same as ruby\'s license'
+      'Ruby'
+    when 'isc license'
+      'ISC'
+    when 'zlib license'
+      'Zlib'
+    when 'postgresql license'
+      'PostgreSQL'
+    else
+      # Still truncate if somehow a long license made it here
+      normalized.length > 100 ? "#{normalized[0..100]}..." : normalized
+    end
+  end
+
+  def license_approved?(license)
+    APPROVED_LICENSES.include?(license) ||
+      APPROVED_LICENSES.any? { |approved| license.match?(/\b#{Regexp.escape(approved)}\b/i) }
+  end
+
+  def load_overrides
+    return {} unless File.exist?(@override_file)
+
+    require 'yaml'
+    YAML.load_file(@override_file) || {}
+  rescue StandardError => e
+    puts "⚠️  Warning: Could not load license overrides: #{e.message}"
+    {}
+  end
+end
+
+# Run license check
+if __FILE__ == $PROGRAM_NAME
+  checker = LicenseChecker.new
+  checker.check_licenses
+end

data/settings.local.json

@@ -0,0 +1,12 @@
+{
+  "permissions": {
+    "allow": [
+      "WebSearch",
+      "Bash(chmod:*)",
+      "Bash(gem install:*)",
+      "Bash(ruby:*)"
+    ],
+    "deny": [],
+    "ask": []
+  }
+}