Delete src/agent_logic.py

src/agent_logic.py

@@ -1,379 +0,0 @@
-import os
-import logging
-import gradio as gr
-from langchain_google_genai import ChatGoogleGenerativeAI
-from langchain_openai import ChatOpenAI # Use this for OpenRouter
-# Remove ChatPromptTemplate import as we'll bypass it for system message
-from langchain_core.output_parsers import StrOutputParser
-from langchain_core.messages import HumanMessage, SystemMessage
-# Import HumanMessagePromptTemplate if needed for other parts, but not for this fix
-import requests
-import tempfile
-import json
-import re # Import regex for parsing
-
-logging.basicConfig(level=logging.INFO)
-
-# --- Constants & Prompts ---
-
-# Expanded Gemini Model List based on user feedback
-VALID_GEMINI_MODELS = [
-    "gemini-1.5-pro-latest", # Default/Recommended
-    "gemini-1.5-flash-latest",
-    "gemini-2.5-flash-preview-04-17", # Added
-    "gemini-2.5-pro-preview-03-25", # Added
-    "gemini-2.0-flash", # Added
-    "gemini-2.0-flash-lite", # Added
-]
-
-# Define the *significantly enhanced* prompt template for detailed tasks
-# Escape literal curly braces by doubling them {{ and }} - This is kept for clarity but won't be parsed by Langchain in the new approach
-system_prompt_base = """You are an expert AI assistant specialized in breaking down software development ideas into **extremely detailed, actionable, step-by-step tasks** for AI-powered coding tools. The user will provide an application idea, a target AI tool, and a desired language (Turkish or English). Your goal is to generate a comprehensive, multi-page plan that the AI tool can follow precisely to build the application.
-
-**Output Requirements:**
-1.  **Language:** Generate the entire response in the requested language ({language}).
-2.  **Format:** Use a numbered list for the main steps. Use sub-bullets (multiple levels if necessary) for intricate details within each step.
-3.  **Detail Level:** Be **extremely specific and verbose**. The output should be **at least two pages long** when rendered normally. Include:
-    *   **Project Setup:** Detailed commands for project initialization (e.g., `npx create-next-app`, `python -m venv venv`), including specific options to select.
-    *   **Project Structure:** Define the complete directory and file structure, explaining the purpose of key files/folders.
-    *   **Libraries/Dependencies:** List all necessary libraries and exact installation commands (e.g., `npm install react react-dom axios` or `pip install flask sqlalchemy flask-cors`).
-    *   **Code Snippets/Examples:** Provide **concrete example code snippets** for key functions, components, or configurations. Do not just describe; show the code.
-    *   **Configuration:** Detail necessary configuration files (e.g., `.env`, `tailwind.config.js`, `database.py`) and provide example settings.
-    *   **Step-by-Step Instructions:** Break down every complex task into the smallest possible, manageable sub-steps. Leave no ambiguity.
-    *   **AI Tool Prompts:** Suggest **very specific, context-rich prompts** the user could give to the target AI tool for each significant code generation or modification step (e.g., "Cursor, in `src/components/AuthForm.js`, generate a React functional component named `AuthForm`. It should include state variables for `email`, `password`, and `isLoading`. Add input fields for email and password, and a submit button. Implement basic form handling with `onSubmit` that logs the email and password for now. Use Tailwind CSS for styling.").
-4.  **Logical Flow:** Ensure tasks are sequential, logical, and build upon each other seamlessly.
-5.  **Completeness:** Cover the entire development lifecycle from setup to basic implementation of core features.
-
-**Target AI Tool Guidance:**
-*   **Cursor:** Focus on tasks involving code generation, refactoring, debugging within an IDE context, using codebase awareness. Emphasize prompts for generating functions, classes, components, files, and modifying existing code based on context.
-*   **Windsurf:** Assume tasks related to web development (React/Next.js focus). Include detailed prompts for UI generation, component creation (with props and state), styling (e.g., Tailwind CSS classes), API integration, and data fetching logic.
-*   **TRAE AI, CLINE, ROOCODE:** Treat as advanced code generation/completion tools. Provide highly detailed instructions for setting up project structure, defining data models/schemas (e.g., SQL table definitions, ORM models), implementing complex core logic (functions, classes, algorithms), creating API endpoints (with request/response examples), generating UI components, and writing unit/integration tests. Specify extremely detailed prompts for each generation step.
-*   **Genel (General):** Provide a comprehensive software development plan covering requirements analysis, detailed architecture design (including technology stack choices, database schema design), meticulous implementation steps for all major features, testing strategy (unit, integration, e2e), and deployment considerations. Maintain an exceptionally high level of detail suitable for guiding a development team.
-
-**Example Task Structure (Illustrative - More Detail Needed in Actual Output):**
-1.  **Project Setup (Next.js Blog):**
-    *   Open your terminal.
-    *   Navigate to your desired projects directory.
-    *   Run the command: `npx create-next-app@latest my-detailed-blog`
-    *   When prompted:
-        *   Select `Yes` for TypeScript.
-        *   Select `Yes` for ESLint.
-        *   Select `Yes` for Tailwind CSS.
-        *   Select `Yes` for `src/` directory.
-        *   Select `Yes` for App Router.
-        *   Select `No` for customizing the default import alias.
-    *   Navigate into the project: `cd my-detailed-blog`
-    *   Verify the structure (show key folders like `src/app`, `src/lib`, `public`, `tailwind.config.ts`).
-2.  **Install Dependencies:**
-    *   Run: `npm install gray-matter react-markdown date-fns`
-    *   Explain purpose: `gray-matter` for frontmatter, `react-markdown` for rendering, `date-fns` for date formatting.
-3.  **Define Blog Post Structure & Content:**
-    *   Create a directory: `mkdir content` at the project root.
-    *   Inside `content`, create `posts` directory: `mkdir content/posts`
-    *   Create an example post file: `content/posts/first-post.md`
-    *   Add content with frontmatter:
-        ```markdown
-        ---
-        title: "My First Detailed Post"
-        date: "2025-05-01"
-        author: "AI Assistant"
-        excerpt: "This is a short summary of the post..."
-        ---
-
-        ## Introduction
-
-        This is the main content of the blog post, written in Markdown.
-
-        *   You can use lists.
-        *   And other Markdown features.
-
-        ```python
-        print("Hello, World!")
-        ```
-        ```
-4.  **Implement Post Utility Functions (`src/lib/posts.ts`):**
-    *   Create the file: `src/lib/posts.ts`
-    *   **Prompt for AI Tool (Cursor):** "In `src/lib/posts.ts`, generate the following TypeScript functions:
-        1.  `getPostsDirectory()`: Returns the absolute path to the `content/posts` directory.
-        2.  `getAllPostIds()`: Reads all filenames in the posts directory and returns an array of objects like `{{ params: {{ id: 'first-post' }} }}` (without the `.md` extension), suitable for Next.js `generateStaticParams`.
-        3.  `getPostData(id: string)`: Takes a post ID (filename without extension), reads the corresponding `.md` file, parses the frontmatter using `gray-matter`, converts the markdown content to HTML using `react-markdown` (or keep as markdown string if rendering client-side), formats the date using `date-fns`, and returns an object containing `id`, `title`, `date`, `author`, `excerpt`, and `contentHtml` (or `contentMarkdown`). Handle potential file read errors.
-        4.  `getSortedPostsData()`: Reads all posts, parses frontmatter, and returns an array of post metadata (`id`, `title`, `date`, `author`, `excerpt`) sorted by date in descending order."
-    *   Add necessary imports: `fs`, `path`, `gray-matter`, `date-fns`.
-5.  **Create Blog Index Page (`src/app/page.tsx`):**
-    *   Clear the default content of `src/app/page.tsx`.
-    *   **Prompt for AI Tool (Cursor/Windsurf):** "Update `src/app/page.tsx` to be an async Server Component. Import `getSortedPostsData` from `src/lib/posts`. Call `getSortedPostsData` to fetch the sorted post metadata. Render a heading 'Blog'. Below the heading, map over the sorted posts data and render a list (`<ul>`). Each list item (`<li>`) should contain:
-        *   A link (`<Link href={{`/posts/${{post.id}}`}}>`) displaying the `post.title`.
-        *   A small text element displaying the formatted `post.date` and `post.author`.
-        *   The `post.excerpt` below the title/date.
-        *   Use Tailwind CSS classes for styling (e.g., `text-2xl font-bold`, `text-gray-600`, `mt-2`). Import `Link` from `next/link`."
-6.  **Create Dynamic Post Page (`src/app/posts/[id]/page.tsx`):**
-    *   Create the directory structure: `src/app/posts/[id]`
-    *   Create the file: `src/app/posts/[id]/page.tsx`
-    *   **Prompt for AI Tool (Cursor/Windsurf):** "Create `src/app/posts/[id]/page.tsx`. Implement the following:
-        1.  Import `getAllPostIds` and `getPostData` from `src/lib/posts`.
-        2.  Implement `generateStaticParams` using `getAllPostIds` to pre-render all post pages at build time.
-        3.  Define the page component as an async function `Post({{ params }}: {{ params: {{ id: string }} }})`.
-        4.  Inside the component, call `getPostData(params.id)` to fetch the specific post data.
-        5.  Render the post content:
-            *   An `<h1>` with the `post.title`.
-            *   A `<div>` with the `post.date` and `post.author`.
-            *   A `<div>` where the `post.contentHtml` (or markdown content rendered with `react-markdown`) is displayed. Use Tailwind's `prose` classes for styling the markdown content if applicable.
-        6.  Add basic error handling if post data is not found."
-7.  ... (Continue with styling refinements, layout component, potential API routes, etc. - BE EXTREMELY DETAILED)
-
-Now, generate the **highly detailed, multi-page** task list based on the user's request below. Ensure the output is in **{language}** and includes **example code snippets**.
-"""
-
-output_parser = StrOutputParser()
-
-# --- API Key & Model Management ---
-
-def validate_gemini_key(api_key):
-    """Validates a Gemini API key by making a simple list_models call."""
-    if not api_key:
-        return False, "API anahtarı boş."
-    try:
-        llm = ChatGoogleGenerativeAI(model="gemini-1.5-flash-latest", google_api_key=api_key, client_options={"api_endpoint": "generativelanguage.googleapis.com"})
-        llm.invoke([HumanMessage(content="Hi")])
-        logging.info("Gemini API key validated successfully.")
-        return True, "Başarıyla Doğrulandı"
-    except Exception as e:
-        logging.error(f"Gemini API key validation failed: {e}")
-        if "API_KEY_INVALID" in str(e):
-             return False, f"Doğrulama Başarısız: Geçersiz API Anahtarı."
-        if "models/gemini-pro" in str(e) or "is not found for API version" in str(e):
-             return False, f"Doğrulama Başarısız: Eski model desteklenmiyor olabilir. Geçerli bir model seçin."
-        return False, f"Doğrulama Başarısız: {e}"
-
-def validate_openrouter_key(api_key):
-    """Validates an OpenRouter API key by making a simple call."""
-    if not api_key:
-        return False, "API anahtarı boş."
-    try:
-        response = requests.get(
-            "https://openrouter.ai/api/v1/auth/key",
-            headers={"Authorization": f"Bearer {api_key}"}
-        )
-        response.raise_for_status()
-        logging.info("OpenRouter API key validated successfully.")
-        return True, "Başarıyla Doğrulandı"
-    except requests.exceptions.RequestException as e:
-        logging.error(f"OpenRouter API key validation failed: {e}")
-        status_code = e.response.status_code if e.response is not None else "N/A"
-        if status_code == 401:
-            return False, f"Doğrulama Başarısız (HTTP {status_code}): Geçersiz API Anahtarı."
-        return False, f"Doğrulama Başarısız (HTTP {status_code}): {e}"
-    except Exception as e:
-        logging.error(f"OpenRouter API key validation failed with unexpected error: {e}")
-        return False, f"Doğrulama Başarısız: {e}"
-
-def save_api_key(api_key, api_type):
-    """Validates and saves the API key to the state."""
-    if api_type == "gemini":
-        is_valid, status_message = validate_gemini_key(api_key)
-    elif api_type == "openrouter":
-        is_valid, status_message = validate_openrouter_key(api_key)
-    else:
-        return None, "Geçersiz API Tipi"
-
-    if is_valid:
-        return api_key, status_message
-    else:
-        return None, status_message
-
-def delete_api_key(api_type):
-    """Deletes the API key from the state."""
-    logging.info(f"Deleting {api_type} API key from state.")
-    return None, "Kaydedilmedi", ""
-
-def list_available_gemini_models():
-    """Returns the updated list of predefined Gemini models."""
-    logging.info("Returning updated predefined Gemini models list.")
-    return VALID_GEMINI_MODELS
-
-def list_available_openrouter_models():
-    """Lists available models from OpenRouter API and returns a list."""
-    try:
-        logging.info("Fetching OpenRouter models...")
-        response = requests.get("https://openrouter.ai/api/v1/models")
-        response.raise_for_status()
-        models_data = response.json().get("data", [])
-        preferred_vendors = ["google", "anthropic", "openai", "mistralai", "meta-llama"]
-        models = sorted(
-            [m["id"] for m in models_data],
-            key=lambda x: ([p not in x.lower() for p in preferred_vendors], x)
-        )
-        logging.info(f"Fetched {len(models)} OpenRouter models.")
-        if not models:
-            models = ["google/gemini-pro"] # Fallback
-        return models
-    except requests.exceptions.RequestException as e:
-        logging.error(f"Error fetching OpenRouter models: {e}")
-        gr.Warning(f"OpenRouter modelleri listelenemedi: {e}")
-        return ["google/gemini-pro"] # Fallback list
-    except Exception as e:
-        logging.error(f"Error processing OpenRouter models: {e}")
-        gr.Warning(f"OpenRouter modelleri işlenirken hata: {e}")
-        return ["google/gemini-pro"] # Fallback list
-
-# --- Task Generation Logic ---
-
-def get_llm(gemini_key, openrouter_key, gemini_model_name, openrouter_model_name):
-    """Initializes and returns the appropriate LLM based on provided keys and model names."""
-    llm = None
-    api_used = None
-    last_error = None
-
-    if gemini_key and gemini_model_name in VALID_GEMINI_MODELS:
-        try:
-            llm = ChatGoogleGenerativeAI(model=gemini_model_name, google_api_key=gemini_key, convert_system_message_to_human=True)
-            logging.info(f"Attempting to use Gemini LLM ({gemini_model_name}).")
-            llm.invoke([HumanMessage(content="Hi")])
-            logging.info(f"Successfully initialized Gemini LLM ({gemini_model_name}).")
-            api_used = "Gemini"
-            return llm, api_used
-        except Exception as e:
-            logging.error(f"Failed to initialize Gemini ({gemini_model_name}): {e}")
-            last_error = e
-            llm = None
-    elif gemini_key:
-        logging.warning(f"Selected Gemini model 	{gemini_model_name}	 is not in the valid list. Skipping Gemini.")
-        last_error = ValueError(f"Geçersiz Gemini modeli seçildi: {gemini_model_name}")
-
-    if openrouter_key and llm is None:
-        try:
-            if not openrouter_model_name:
-                raise ValueError("OpenRouter modeli seçilmedi.")
-            llm = ChatOpenAI(
-                model=openrouter_model_name,
-                openai_api_key=openrouter_key,
-                openai_api_base="https://openrouter.ai/api/v1",
-            )
-            logging.info(f"Attempting to use OpenRouter LLM ({openrouter_model_name}).")
-            llm.invoke([HumanMessage(content="Hi")])
-            logging.info(f"Successfully initialized OpenRouter LLM ({openrouter_model_name}).")
-            api_used = "OpenRouter"
-            return llm, api_used
-        except Exception as e:
-            logging.error(f"Failed to initialize OpenRouter ({openrouter_model_name}): {e}")
-            if last_error is None or not gemini_key:
-                last_error = e
-
-    if llm is None:
-        if not gemini_key and not openrouter_key:
-            raise gr.Error("API anahtarı sağlanmadı.")
-        elif last_error:
-             if isinstance(last_error, ValueError) and "OpenRouter modeli seçilmedi" in str(last_error):
-                 raise gr.Error(str(last_error))
-             if "API_KEY_INVALID" in str(last_error) or "401" in str(last_error):
-                 raise gr.Error("LLM başlatılamadı: Geçersiz API Anahtarı.")
-             raise gr.Error(f"LLM başlatılamadı. Son hata: {last_error}")
-        else:
-             raise gr.Error("LLM başlatılırken bilinmeyen bir hata oluştu.")
-    else:
-        return llm, api_used
-
-def generate_tasks_for_idea(idea, gemini_key, openrouter_key, target_tool, gemini_model_name, openrouter_model_name, language):
-    """Generates tasks based on an application idea using Langchain and an LLM, in the specified language."""
-    logging.info(f"Generating tasks for idea: 	{idea[:50]}...	, Target Tool: {target_tool}, Language: {language}")
-
-    if not idea:
-        yield "Hata: Lütfen bir uygulama fikri girin."
-        return
-
-    if not gemini_key and not openrouter_key:
-        yield "Hata: Lütfen en az bir API anahtarı (Gemini veya OpenRouter) girin."
-        return
-
-    try:
-        llm, api_used = get_llm(gemini_key, openrouter_key, gemini_model_name, openrouter_model_name)
-        logging.info(f"Successfully initialized LLM using {api_used}.")
-
-        # --- Alternative Prompt Approach --- 
-        # 1. Format the system prompt with the language
-        formatted_system_prompt = system_prompt_base.format(language=language)
-        
-        # 2. Create the human message content
-        human_message_content = f"Application Idea: {idea}\nTarget AI Tool: {target_tool}"
-        
-        # 3. Create the messages list manually
-        messages = [
-            SystemMessage(content=formatted_system_prompt),
-            HumanMessage(content=human_message_content)
-        ]
-        # --- End of Alternative Approach ---
-
-        logging.info("Invoking LLM directly with messages list...")
-        # Invoke the LLM directly with the list of messages
-        response_stream = llm.stream(messages)
-
-        full_response = ""
-        yield "Detaylı görevler oluşturuluyor, lütfen bekleyin...\n\n" # Initial message
-        for chunk in response_stream:
-            # Access the content attribute of the AIMessage chunk
-            if hasattr(chunk, 'content'):
-                full_response += chunk.content
-                yield full_response
-            else:
-                # Handle potential non-AIMessage chunks if necessary (e.g., errors)
-                logging.warning(f"Received unexpected chunk type: {type(chunk)}")
-
-        logging.info("Detailed task generation complete.")
-
-    except gr.Error as e:
-        logging.error(f"Gradio Error during task generation: {e}")
-        yield f"Hata: {e}"
-    except Exception as e:
-        # Check specifically for the template formatting error again (shouldn't happen now)
-        if "unexpected '{' in field name" in str(e):
-             logging.error(f"Template formatting error persisted unexpectedly: {e}", exc_info=True)
-             yield f"Hata: Prompt şablonu hatası devam ediyor. Lütfen geliştiriciye bildirin. Hata: {e}"
-        else:
-             logging.error(f"Error during task generation: {e}", exc_info=True)
-             yield f"Görev oluşturulurken bir hata oluştu: {e}. Lütfen API anahtarlarınızı, model seçiminizi ve ağ bağlantınızı kontrol edin."
-
-# --- Task Downloading Logic ---
-
-def format_tasks_for_download(tasks_text, file_format):
-    """Formats the generated tasks text into the specified file format and returns the file path."""
-    if not tasks_text or tasks_text.startswith("Detaylı görevler oluşturuluyor"):
-        gr.Warning("İndirilecek geçerli görev bulunmuyor.")
-        return None
-
-    try:
-        suffix = ".txt"
-        content = tasks_text
-        if file_format == "Markdown":
-            suffix = ".md"
-            content = tasks_text # Assume LLM output is already markdown
-        elif file_format == "JSON":
-            suffix = ".json"
-            tasks_list = []
-            current_task_lines = []
-            task_pattern = re.compile(r"^\s*\d+\.\s+")
-
-            for line in tasks_text.strip().split("\n"):
-                line_strip = line.strip()
-                if task_pattern.match(line_strip):
-                    if current_task_lines:
-                        tasks_list.append("\n".join(current_task_lines).strip())
-                    current_task_lines = [task_pattern.sub("", line_strip)]
-                elif line_strip or current_task_lines:
-                    current_task_lines.append(line)
-
-            if current_task_lines:
-                tasks_list.append("\n".join(current_task_lines).strip())
-
-            content = json.dumps({"tasks": tasks_list}, indent=4, ensure_ascii=False)
-
-        with tempfile.NamedTemporaryFile(mode="w", suffix=suffix, delete=False, encoding="utf-8") as temp_file:
-            temp_file.write(content)
-            file_path = temp_file.name
-            logging.info(f"Tasks formatted as {file_format} and saved to temporary file: {file_path}")
-            return file_path
-
-    except Exception as e:
-        logging.error(f"Error formatting tasks for download: {e}")
-        gr.Error(f"Görevler indirilirken hata oluştu: {e}")
-        return None
-