small llm feedack fixes (#97)

* Simplify LLM feedback code while maintaining core functionality

- Streamlined UI with cleaner layout and better visual hierarchy
- Reduced CSS by 70% using a simpler container-based approach
- Simplified JavaScript from ~400 lines to ~130 lines
- Improved state management and evolution logic
- Maintained all core functionality including art generation, preview, and history

Closes #91

Mentat precommits passed. Log: https://mentat.ai/log/ccb24099-4857-47b7-b5d7-d856a21c9041

* Update .gitignore with additional common patterns

Added patterns for:
- Yarn PnP files
- Additional build output directory (out/)
- General debug logs
- OS-specific files (DS_Store, Thumbs.db)

Mentat precommits passed. Log: https://mentat.ai/log/75248827-ef9b-4de6-9167-557d758749fb

* Make .gitignore more comprehensive for all app types

- Removed wildcard prefixes to work recursively at any depth
- Added patterns for various build tools and frameworks
- Added web-specific patterns for compiled assets
- Added testing and temporary file patterns
- Improved organization and categorization

Mentat precommits passed. Log: https://mentat.ai/log/9478638d-b20e-4b73-a8ec-7dc7c7cfd202

* Update .gitignore to better handle subfolder apps

- Added `**/` prefix to match files at any directory depth
- Added patterns for Yarn 2+ cache files
- Included vanilla HTML/JS specific patterns
- Added more build output and test directories
- Improved handling of OS-specific files at all levels

Mentat precommits passed. Log: https://mentat.ai/log/4786f47d-56c8-44b6-bb53-1e2e7696062a

* Revert "Make .gitignore more comprehensive for all app types"

This reverts commit a424654.

* enhance visual poetry UI and generation

enhance visual poetry UI and generation

- Update presets to focus on visual poetry styles (Apollinaire, Mallarmé, etc)
- Improve monospace text display with better styling and dimensions
- Add seed parameter for reproducible generations
- Remove separate current art window in favor of preview
- Enhance generation logic with better state management
- Improve error handling and logging

* Tweaks more prompts

* add model selector

* more robust fetching logic

* small tweaks

* improvements

* Enforce dot usage over whitespace in guidelines

* more robust and post

---------

Co-authored-by: MentatBot <160964065+MentatBot@users.noreply.github.com>

Author: voodoohop

llm-feedback/index.html

@@ -282,76 +282,42 @@ <h2>History</h2>
 
                 elements.start.textContent = 'Generating...';
 
-                const encodedPrompt = encodeURIComponent(currentState);
-                const encodedSystem = encodeURIComponent(formatInstructions);
-                
                 let seed = elements.seed.value && elements.seed.value !== '-1' ? 
                     parseInt(elements.seed.value) : 
                     Math.floor(Math.random() * 1000000);
-                elements.seed.value = seed; // Update input with chosen seed
-                
-                let response = null;
-                console.log('Fetching...');
-                
-                let retryCount = 0;
-                const maxRetries = 3;
-                const retryDelay = 15000; // 15 seconds delay between retries
-                const timeoutDuration = 20000; // 20 seconds timeout
-                
-                do {
-                    try {
-                        const url = `https://text.pollinations.ai/${encodedPrompt}?system=${encodedSystem}&seed=${seed}&model=${getSelectedModel()}&temperature=${elements.temperature.value}`;
-                        console.log('Request URL:', url);
-                        
-                        const controller = new AbortController();
-                        const timeout = setTimeout(() => {
-                            controller.abort();
-                        }, timeoutDuration);
-                        
-                        try {
-                            response = await fetch(url, {
-                                signal: controller.signal
-                            });
-                            clearTimeout(timeout);
-                        } catch (error) {
-                            clearTimeout(timeout);
-                            if (error.name === 'AbortError') {
-                                throw new Error('Request timed out after ' + timeoutDuration/1000 + ' seconds');
-                            }
-                            throw error;
-                        }
-                        
-                        if (!response.ok) {
-                            retryCount++;
-                            if (retryCount >= maxRetries) {
-                                console.error(`Failed after ${maxRetries} attempts. Stopping.`);
-                                elements.start.textContent = 'Start Evolution';
-                                return '';
-                            }
-                            console.log(`Attempt ${retryCount}/${maxRetries} failed. Waiting ${retryDelay/1000} seconds before retry...`);
-                            seed = seed + 1;
-                            await new Promise(resolve => setTimeout(resolve, retryDelay));
-                            continue;
-                        }
-                        
-                        const text = await response.text();
-                        console.log('Raw response:', text);
-                        elements.start.textContent = 'Start Evolution';
-                        return text;
-                        
-                    } catch (error) {
-                        console.error('Fetch error:', error);
-                        retryCount++;
-                        if (retryCount >= maxRetries) {
-                            console.error(`Failed after ${maxRetries} attempts. Stopping.`);
-                            elements.start.textContent = 'Start Evolution';
-                            return '';
-                        }
-                        console.log(`Attempt ${retryCount}/${maxRetries} failed. Waiting ${retryDelay/1000} seconds before retry...`);
-                        await new Promise(resolve => setTimeout(resolve, retryDelay));
+
+                const messages = [
+                    {
+                        role: "system",
+                        content: formatInstructions
+                    },
+                    {
+                        role: "user",
+                        content: currentState
                     }
-                } while (retryCount < maxRetries);
+                ];
+
+                const response = await fetch('https://text.pollinations.ai/', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                    body: JSON.stringify({
+                        messages: messages,
+                        model: getSelectedModel(),
+                        temperature: parseFloat(elements.temperature.value),
+                        seed: seed
+                    })
+                });
+                
+                if (!response.ok) {
+                    console.error(`Failed to generate text: ${response.status} ${response.statusText}`);
+                    elements.start.textContent = 'Start Evolution';
+                    return '';
+                }
 
+                const text = await response.text();
+                console.log('Raw response:', text);
                 elements.start.textContent = 'Start Evolution';
                 return '';
             } catch (error) {
@@ -398,7 +364,7 @@ <h2>History</h2>
 
                     // Wait 3 seconds before next iteration
                     console.log('Waiting 3 seconds...');
-                    await new Promise(resolve => setTimeout(resolve, 1000));
+                    await new Promise(resolve => setTimeout(resolve, 2000));
                     console.log('Wait complete');
                 } catch (error) {
                     console.error('Evolution error:', error);