RuboCop::Prompt

gem 'rubocop-prompt'

class PromptHandler
  def generate_system_prompt(user_input)
    <<~SYSTEM
      You are an AI assistant. User said: #{user_input}
    SYSTEM
  end
end

class PromptHandler
  def generate_system_prompt
    <<~SYSTEM
      You are an AI assistant.
    SYSTEM
  end

  # Handle user input separately
  def process_user_input(user_input)
    # Process and sanitize user input here
  end
end

class PromptGenerator
  def create_system_prompt
    # This example assumes a very long prompt that exceeds the token limit
    <<~PROMPT
      # System Instructions

      You are an AI assistant with extensive knowledge about many topics.
      [... thousands of lines of detailed instructions that exceed 4000 tokens ...]
      Please follow all these detailed guidelines carefully.
    PROMPT
  end
end

class PromptGenerator
  def create_system_prompt
    <<~PROMPT
      # System Instructions

      You are a helpful AI assistant.

      ## Guidelines
      - Be concise and accurate
      - Ask for clarification when needed
      - Provide helpful responses
    PROMPT
  end

  # For complex prompts, consider breaking them into smaller, focused components
  def create_specialized_prompt(domain)
    base_prompt = create_system_prompt
    domain_specific = load_domain_instructions(domain)  # Keep each part manageable
    "#{base_prompt}\n\n#{domain_specific}"
  end
end

class ChatService
  def generate_response
    OpenAI::Client.new.chat(
      parameters: {
        model: "gpt-4",
        messages: [{ role: "user", content: "Hello" }]
      }
    )
  end

  # Also bad - variable client without stop controls
  def chat_completion(user_msg, context)
    client = OpenAI::Client.new(access_token: ENV["OPENAI_API_KEY"])
    client.chat(parameters: {
      model: "gpt-4o-mini",
      messages: [
        { role: "system", content: "You are an AI assistant" },
        { role: "user", content: "#{user_msg}\n\n### 参考資料\n#{context}" }
      ]
    })
  end
end

class ChatService
  def generate_response_with_limit
    OpenAI::Client.new.chat(
      parameters: {
        model: "gpt-4",
        messages: [{ role: "user", content: "Hello" }],
        max_tokens: 100
      }
    )
  end

  def generate_response_with_stop
    OpenAI::Client.new.chat(
      parameters: {
        model: "gpt-4",
        messages: [{ role: "user", content: "Hello" }],
        stop: ["END", "\n"]
      }
    )
  end

  def generate_response_with_both
    OpenAI::Client.new.chat(
      parameters: {
        model: "gpt-4",
        messages: [{ role: "user", content: "Hello" }],
        max_tokens: 1000,
        stop: ["END"]
      }
    )
  end
end

class PromptGenerator
  def analysis_prompt
    OpenAI::Client.new.chat(
      parameters: {
        temperature: 0.9,  # Too high for precision task
        messages: [
          { role: "system", content: "Analyze this data accurately and provide precise results" }
        ]
      }
    )
  end

  def calculation_prompt
    client.chat(
      temperature: 0.8,  # Too high for calculation task
      messages: [
        { role: "user", content: "Calculate the exact total of these numbers" }
      ]
    )
  end
end

class PromptGenerator
  # Low temperature for precision tasks
  def analysis_prompt
    OpenAI::Client.new.chat(
      parameters: {
        temperature: 0.3,  # Appropriate for precision
        messages: [
          { role: "system", content: "Analyze this data accurately and provide precise results" }
        ]
      }
    )
  end

  # High temperature is fine for creative tasks
  def creative_prompt
    client.chat(
      parameters: {
        temperature: 0.9,  # Fine for creative tasks
        messages: [
          { role: "user", content: "Write a creative story about space adventures" }
        ]
      }
    )
  end
end

# Bad - will trigger offense
class PromptService
  def call
    { system: "You are an AI assistant." }
  end
end

# Good - properly structured
class PromptService
  def call
    {
      system: <<~PROMPT
        # System Instructions

        You are an AI assistant that helps users with their questions.

        ## Guidelines
        - Be helpful and accurate
        - Provide clear explanations
      PROMPT
    }
  end
end

# Bad - will trigger offense
class PromptHandler
  def process
    {
      system: <<~PROMPT
        # System Instructions
        You are an AI assistant.
        Please help users with their questions.
        ### Important Note
        This is a critical section.
        More instructions follow.
        Final instructions here.
      PROMPT
    }
  end
end

# Good - critical section at beginning
class PromptHandler
  def process
    {
      system: <<~PROMPT
        ### Important Note
        This is a critical section.
        # System Instructions
        You are an AI assistant.
        Please help users with their questions.
      PROMPT
    }
  end
end

# Good - critical section at end
class PromptHandler
  def process
    {
      system: <<~PROMPT
        # System Instructions
        You are an AI assistant.
        Please help users with their questions.
        ### Important Note
        This is a critical section.
      PROMPT
    }
  end
end

# Triggers Prompt/InvalidFormat - no heading
class UserPromptGenerator
  def system_message
    { system: "Help the user with their request" }
  end
end

# Triggers Prompt/SystemInjection - dangerous interpolation
class ChatPromptService
  def generate_system_prompt(user_input)
    <<~SYSTEM
      You are an AI assistant. User said: #{user_input}
    SYSTEM
  end
end

# Triggers Prompt/MissingStop - no termination control
class ChatService
  def generate_response
    OpenAI::Client.new.chat(
      parameters: {
        model: "gpt-4",
        messages: [{ role: "user", content: "Hello" }]
      }
    )
  end
end

# ✅ Proper formatting with headings
class PromptBuilder
  def build
    {
      system: <<~MARKDOWN
        # AI Assistant Instructions

        You are a helpful AI assistant.

        ## Guidelines
        - Be helpful and accurate
        - Ask for clarification when needed
      MARKDOWN
    }
  end
end

# ✅ Safe prompt handling without injection risks
class SecurePromptService
  def generate_system_prompt
    <<~SYSTEM
      # AI Assistant Instructions

      You are a helpful AI assistant.
    SYSTEM
  end

  def process_user_input(user_input)
    # Handle user input separately with proper validation
  end
end

# ✅ Proper API usage with termination controls
class ControlledChatService
  def generate_response
    OpenAI::Client.new.chat(
      parameters: {
        model: "gpt-4",
        messages: [{ role: "user", content: "Hello" }],
        max_tokens: 100,
        stop: ["END"]
      }
    )
  end
end

# ✅ Won't be flagged - not prompt-related
class DatabaseService
  def config
    { system: "production" }  # Ignored by all prompt cops
  end
end