ai_client.py

"""
AI Client for Grammar Analysis
Uses Google Gemini API (set GOOGLE_API_KEY in your environment).
"""
import os

SYSTEM_PROMPT = """You are an expert in Compiler Design and Context-Free Grammars (CFG).

Your task is to analyze a user-provided grammar and perform three main functions:
1. Validate the grammar
2. Identify issues and suggest fixes
3. Generate valid sample strings

━━━━━━━━━━━━━━━━━━━━━━━
1. VALIDATION
━━━━━━━━━━━━━━━━━━━━━━━
Check whether the grammar is structurally correct:

- Each production must follow: LHS -> RHS1 | RHS2
- LHS must be a single non-terminal
- Symbols must be space-separated
- Detect invalid or malformed rules
- Ensure consistency in symbol usage (no symbol should behave as both terminal and non-terminal)

━━━━━━━━━━━━━━━━━━━━━━━
2. ISSUE DETECTION
━━━━━━━━━━━━━━━━━━━━━━━
Identify and report:

- Undefined non-terminals
- Unreachable symbols
- Non-productive symbols
- Nullable symbols (derive epsilon)
- Direct or indirect left recursion
- Left factoring issues (common prefixes)
- Obvious ambiguity patterns (e.g., E -> E + E)

Do NOT claim ambiguity with certainty unless it is obvious.

━━━━━━━━━━━━━━━━━━━━━━━
3. SUGGESTIONS
━━━━━━━━━━━━━━━━━━━━━━━
For each issue found:

- Explain clearly what is wrong
- Suggest how to fix it
- If possible, show the corrected form of the production

Keep suggestions simple and practical.

━━━━━━━━━━━━━━━━━━━━━━━
4. SAMPLE STRING GENERATION
━━━━━━━━━━━━━━━━━━━━━━━
Generate 3-5 valid sample strings from the grammar:

- Strings must be derivable from the start symbol
- Keep them simple and meaningful
- Show at least one longer derivation if possible

━━━━━━━━━━━━━━━━━━━━━━━
OUTPUT FORMAT (STRICT)
━━━━━━━━━━━━━━━━━━━━━━━

VALIDITY:
(Valid / Invalid with reason)

ISSUES:
- ...

SUGGESTIONS:
- ...

SAMPLE STRINGS:
- ...
- ...

SUMMARY:
(Short 2-3 line conclusion)

━━━━━━━━━━━━━━━━━━━━━━━
IMPORTANT RULES:
━━━━━━━━━━━━━━━━━━━━━━━

- Do NOT hallucinate rules or symbols
- If uncertain, say: "Cannot be determined definitively"
- Treat epsilon as the empty string
- Be concise but clear
- Do not generate overly complex strings"""


class GeminiClient:
    """Wrapper around Google Gemini for grammar analysis (mirrors original inputAI.py)."""

    def __init__(self, api_key: str = None):
        self.api_key = api_key or os.getenv("GOOGLE_API_KEY", "")
        self._model = None

    def _get_model(self):
        if self._model is None:
            try:
                import google.generativeai as genai
            except ImportError:
                raise RuntimeError(
                    "google-generativeai not installed. Run: pip install google-generativeai"
                )
            if not self.api_key:
                raise ValueError("Missing GOOGLE_API_KEY")
            genai.configure(api_key=self.api_key)
            self._model = genai.GenerativeModel("gemma-4-26"
                                                "b-a4b-it")
        return self._model

    def analyze_grammar(self, grammar_text: str) -> str:
        """Send grammar to Gemini for analysis."""
        if not self.api_key:
            return (
                "No GOOGLE_API_KEY found.\n"
                "Set it in your environment:  export GOOGLE_API_KEY=your-key-here\n"
                "Then restart the Streamlit app."
            )
        try:
            model = self._get_model()
            full_prompt = f"{SYSTEM_PROMPT}\n\nUser: {grammar_text}"
            response = model.generate_content(full_prompt)
            return response.text
        except Exception as exc:
            return f"AI Error: {exc}"

    def ask_followup(self, grammar_text: str, previous_analysis: str, question: str) -> str:
        """Ask a follow-up question about the grammar."""
        if not self.api_key:
            return "No GOOGLE_API_KEY found."
        try:
            model = self._get_model()
            full_prompt = (
                f"{SYSTEM_PROMPT}\n\n"
                f"Grammar:\n{grammar_text}\n\n"
                f"Previous analysis:\n{previous_analysis}\n\n"
                f"User follow-up question: {question}\n\n"
                f"Answer concisely and helpfully."
            )
            response = model.generate_content(full_prompt)
            return response.text
        except Exception as exc:
            return f"AI Error: {exc}"