Role: AI AssistantGoal: Execute the specified task with absolute precision, robustness, and full adherence to the intended functionality.Constraints:- Operate without errors, omissions, or deviations from the defined purpose.- Ensure maximum reliability and performance under all expected conditions.- Do not introduce assumptions, interpretations, or modifications beyond the defined scope.Steps:1. Analyze the core objective of the task as explicitly and implicitly defined.2. Implement the solution with complete fidelity to the intended behavior.3. Reinforce all components to ensure flawless, brute-force reliability.4. Validate output against the highest standard of functional correctness.5. Deliver the final result in a fully optimized, error-free state.Success Criteria: The output must perform perfectly, consistently, and robustly according to the original intent, with no failure under expected use.

script.js

@@ -30,46 +30,93 @@ const examples = [
     "Write code to connect to a database",
     "Create an API endpoint for user authentication"
 ];
-
 // Optimization templates and rules
 const optimizationRules = {
     // Add structured sections
     addStructure: (text) => {
-        const hasRole = /role|you are|act as/i.test(text);
-        const hasGoal = /goal|objective|purpose|create|build|make/i.test(text);
-        const hasConstraints = /constraint|limitation|requirement|must|should/i.test(text);
-        const hasSteps = /step|process|method|first|then|finally/i.test(text);
+        const hasRole = /^role:/im.test(text.trim());
+        const hasGoal = /^goal:/im.test(text.trim());
+        const hasConstraints = /^constraints:/im.test(text.trim());
+        const hasSteps = /^steps:/im.test(text.trim());
+        const hasSuccess = /^success criteria:/im.test(text.trim());
         
         let structured = '';
         
         if (!hasRole) {
-            structured += 'ROLE: [Specify the AI persona or role]\n\n';
+            structured += 'Role: AI Assistant\n';
+        } else {
+            const roleMatch = text.match(/^role:(.+?)(?=\n\w+:|$)/im);
+            if (roleMatch) {
+                structured += 'Role: ' + roleMatch[1].trim() + '\n';
+            }
         }
         
+        structured += '\n';
+        
         if (!hasGoal) {
-            structured += 'GOAL: [Clearly define the primary objective]\n\n';
+            structured += 'Goal: Execute the specified task with absolute precision, robustness, and full adherence to the intended functionality.\n';
         } else {
-            structured += extractSection(text, 'GOAL') + '\n\n';
+            const goalMatch = text.match(/^goal:(.+?)(?=\n\w+:|$)/im);
+            if (goalMatch) {
+                structured += 'Goal: ' + goalMatch[1].trim() + '\n';
+            }
         }
         
+        structured += '\n';
+        
         if (!hasConstraints) {
-            structured += 'CONSTRAINTS:\n- [List specific limitations or requirements]\n- [Add technical specifications]\n- [Include quality criteria]\n\n';
+            structured += 'Constraints:\n- Operate without errors, omissions, or deviations from the defined purpose.\n- Ensure maximum reliability and performance under all expected conditions.\n- Do not introduce assumptions, interpretations, or modifications beyond the defined scope.\n';
         } else {
-            structured += extractSection(text, 'CONSTRAINTS') + '\n\n';
+            const constraintsMatch = text.match(/^constraints:(.+?)(?=\n\w+:|$)/ims);
+            if (constraintsMatch) {
+                const constraints = constraintsMatch[1].trim().split('\n');
+                structured += 'Constraints:\n';
+                constraints.forEach(line => {
+                    if (line.trim()) {
+                        if (!line.startsWith('-')) {
+                            structured += '- ' + line.trim() + '\n';
+                        } else {
+                            structured += line.trim() + '\n';
+                        }
+                    }
+                });
+            }
         }
         
+        structured += '\n';
+        
         if (!hasSteps) {
-            structured += 'EXECUTION STEPS:\n1. [Initial action or analysis]\n2. [Secondary process]\n3. [Final output or deliverable]\n\n';
+            structured += 'Steps:\n1. Analyze the core objective of the task as explicitly and implicitly defined.\n2. Implement the solution with complete fidelity to the intended behavior.\n3. Reinforce all components to ensure flawless, brute-force reliability.\n4. Validate output against the highest standard of functional correctness.\n5. Deliver the final result in a fully optimized, error-free state.\n';
         } else {
-            structured += extractSection(text, 'STEPS') + '\n\n';
+            const stepsMatch = text.match(/^steps:(.+?)(?=\n\w+:|$)/ims);
+            if (stepsMatch) {
+                const steps = stepsMatch[1].trim().split('\n');
+                structured += 'Steps:\n';
+                let stepNum = 1;
+                steps.forEach(line => {
+                    if (line.trim()) {
+                        const cleanLine = line.replace(/^\d+\.?\s*/, '').trim();
+                        structured += stepNum + '. ' + cleanLine + '\n';
+                        stepNum++;
+                    }
+                });
+            }
         }
         
-        structured += 'OUTPUT FORMAT:\n[Specify the exact format and structure of the expected output]';
+        structured += '\n';
+        
+        if (!hasSuccess) {
+            structured += 'Success Criteria: The output must perform perfectly, consistently, and robustly according to the original intent, with no failure under expected use.';
+        } else {
+            const successMatch = text.match(/^success criteria:(.+?)(?=\n\w+:|$)/im);
+            if (successMatch) {
+                structured += 'Success Criteria: ' + successMatch[1].trim();
+            }
+        }
         
         return structured;
     },
-    
-    // Convert to imperative commands
+// Convert to imperative commands
     makeImperative: (text) => {
         return text
             .replace(/I want you to/gi, 'CREATE')
@@ -103,24 +150,49 @@ const optimizationRules = {
         return text;
     }
 };
-
-// Extract sections from text
+// Extract sections from text - Enhanced for precision
 function extractSection(text, sectionType) {
     const lines = text.split('\n');
     let section = '';
+    let inSection = false;
+    const sectionPatterns = {
+        'ROLE': /^role:/im,
+        'GOAL': /^goal:/im,
+        'CONSTRAINTS': /^constraints?:/im,
+        'STEPS': /^steps?:/im,
+        'SUCCESS CRITERIA': /^success criteria:/im
+    };
     
     for (const line of lines) {
-        if (line.toLowerCase().includes(sectionType.toLowerCase()) || 
-            (sectionType === 'GOAL' && /create|build|make|develop/i.test(line)) ||
-            (sectionType === 'CONSTRAINTS' && /must|should|require|limit/i.test(line)) ||
-            (sectionType === 'STEPS' && /step|first|then|finally/i.test(line))) {
+        const trimmedLine = line.trim();
+        
+        // Check if we're entering the target section
+        if (sectionPatterns[sectionType] && sectionPatterns[sectionType].test(trimmedLine)) {
+            inSection = true;
+            section += line + '\n';
+            continue;
+        }
+        
+        // Check if we're entering a different section (exit current section)
+        if (inSection) {
+            let foundNewSection = false;
+            for (const [key, pattern] of Object.entries(sectionPatterns)) {
+                if (key !== sectionType && pattern.test(trimmedLine)) {
+                    foundNewSection = true;
+                    break;
+                }
+            }
+            if (foundNewSection) break;
+        }
+        
+        // Add line if we're in the target section
+        if (inSection) {
             section += line + '\n';
         }
     }
     
     return section || `${sectionType}:\n${text}`;
 }
-
 // Optimize the input text
 function optimizeText() {
     const input = inputText.value.trim();
@@ -172,21 +244,42 @@ function updateCharCount() {
     const count = outputText.value.length;
     charCount.textContent = `${count} characters`;
 }
-
-// Calculate optimization score
+// Calculate optimization score - Enhanced for precision
 function updateOptimizationScore(original, optimized) {
     const originalWords = original.split(/\s+/).length;
     const optimizedWords = optimized.split(/\s+/).length;
-    const structureScore = (optimized.match(/ROLE|GOAL|CONSTRAINTS|STEPS|OUTPUT/gi) || []).length * 20;
-    const precisionScore = (optimized.match(/optimal|specific|precise|exact|define/gi) || []).length * 5;
-    const commandScore = (optimized.match(/CREATE|EXECUTE|GENERATE|IMPLEMENT|ENSURE/gi) || []).length * 3;
     
-    const score = Math.min(100, structureScore + precisionScore + commandScore);
+    // Check for required structure components
+    const hasRole = /^role:/im.test(optimized);
+    const hasGoal = /^goal:/im.test(optimized);
+    const hasConstraints = /^constraints:/im.test(optimized);
+    const hasSteps = /^steps:/im.test(optimized);
+    const hasSuccess = /^success criteria:/im.test(optimized);
+    
+    const structureScore = (hasRole + hasGoal + hasConstraints + hasSteps + hasSuccess) * 20;
+    
+    // Check for precision keywords
+    const precisionKeywords = /precision|robustness|reliability|consistently|flawless|maximum|absolute/gi;
+    const precisionCount = (optimized.match(precisionKeywords) || []).length;
+    const precisionScore = Math.min(20, precisionCount * 4);
+    
+    // Check for action-oriented language
+    const actionKeywords = /execute|implement|validate|deliver|analyze|reinforce/gi;
+    const actionCount = (optimized.match(actionKeywords) || []).length;
+    const actionScore = Math.min(20, actionCount * 4);
+    
+    // Clarity and specificity bonus
+    const clarityBonus = optimized.includes('no failure under expected use') ? 10 : 0;
+    const specificityBonus = optimized.includes('highest standard') ? 10 : 0;
+    
+    const score = Math.min(100, structureScore + precisionScore + actionScore + clarityBonus + specificityBonus);
     
     let scoreColor = 'text-red-500';
-    if (score >= 80) scoreColor = 'text-green-500';
-    else if (score >= 60) scoreColor = 'text-yellow-500';
-    else if (score >= 40) scoreColor = 'text-orange-500';
+    if (score >= 95) scoreColor = 'text-green-500';
+    else if (score >= 85) scoreColor = 'text-green-600';
+    else if (score >= 75) scoreColor = 'text-yellow-500';
+    else if (score >= 65) scoreColor = 'text-orange-500';
+    else if (score >= 50) scoreColor = 'text-red-600';
     
     optimizationScore.textContent = `Optimization Score: ${score}/100`;
     optimizationScore.className = `font-semibold ${scoreColor} score-update`;
@@ -195,34 +288,52 @@ function updateOptimizationScore(original, optimized) {
         optimizationScore.classList.remove('score-update');
     }, 500);
 }
-
-// Update analysis section
+// Update analysis section - Enhanced for robustness
 function updateAnalysis(original, optimized) {
     beforeText.textContent = original;
     afterText.textContent = optimized;
     
     const improvements = [];
+    const structureComponents = ['Role', 'Goal', 'Constraints', 'Steps', 'Success Criteria'];
     
-    if (original.split(/\s+/).length < optimized.split(/\s+/).length) {
-        improvements.push('✅ Added structural clarity with defined sections');
-    }
+    // Check for structure components
+    structureComponents.forEach(component => {
+        const pattern = new RegExp(`^${component}:`, 'im');
+        if (!pattern.test(original) && pattern.test(optimized)) {
+            improvements.push(`✅ Added ${component} section for comprehensive structure`);
+        }
+    });
     
-    if (/[a-z]+ [a-z]+ [a-z]+/i.test(original)) {
-        improvements.push('✅ Converted vague statements to precise commands');
+    // Check for precision enhancements
+    if (!/precision|robustness|reliability|absolute/gi.test(original)) {
+        improvements.push('✅ Enhanced with precision-focused language');
     }
     
-    if (!/constraint|requirement|limit/i.test(original)) {
-        improvements.push('✅ Added clear constraints and boundaries');
+    if (!/maximum|flawless|consistent/gi.test(original)) {
+        improvements.push('✅ Added reliability and consistency requirements');
     }
     
-    if (!/step|process|method/i.test(original)) {
-        improvements.push('✅ Defined execution steps for clarity');
+    // Check for action-oriented transformation
+    if (!/execute|implement|validate|deliver/gi.test(original)) {
+        improvements.push('✅ Transformed to action-oriented directives');
     }
     
-    if (!/output format|deliverable|result/i.test(original)) {
-        improvements.push('✅ Specified expected output format');
+    // Check for error prevention
+    if (!/without errors|no failure|no deviations/gi.test(original)) {
+        improvements.push('✅ Implemented error prevention measures');
     }
     
+    // Calculate metrics
+    const hasRole = /^role:/im.test(optimized);
+    const hasGoal = /^goal:/im.test(optimized);
+    const hasConstraints = /^constraints:/im.test(optimized);
+    const hasSteps = /^steps:/im.test(optimized);
+    const hasSuccess = /^success criteria:/im.test(optimized);
+    const structureCount = [hasRole, hasGoal, hasConstraints, hasSteps, hasSuccess].filter(Boolean).length;
+    
+    const precisionCount = (optimized.match(/precision|robustness|reliability|absolute|flawless|maximum/gi) || []).length;
+    const actionCount = (optimized.match(/execute|implement|validate|deliver|analyze|reinforce/gi) || []).length;
+    
     const analysisHTML = `
         <div class="space-y-3">
             <div class="bg-blue-50 p-3 rounded-lg">
@@ -236,20 +347,25 @@ function updateAnalysis(original, optimized) {
                 <div class="grid grid-cols-2 gap-2 text-sm">
                     <div>Original Words: <span class="font-semibold">${original.split(/\s+/).length}</span></div>
                     <div>Optimized Words: <span class="font-semibold">${optimized.split(/\s+/).length}</span></div>
-                    <div>Structure Added: <span class="font-semibold">${(optimized.match(/ROLE|GOAL|CONSTRAINTS|STEPS|OUTPUT/gi) || []).length}</span></div>
-                    <div>Commands Added: <span class="font-semibold">${(optimized.match(/CREATE|EXECUTE|GENERATE|IMPLEMENT/gi) || []).length}</span></div>
+                    <div>Structure Components: <span class="font-semibold">${structureCount}/5</span></div>
+                    <div>Precision Keywords: <span class="font-semibold">${precisionCount}</span></div>
+                    <div>Action Directives: <span class="font-semibold">${actionCount}</span></div>
+                    <div>Robustness Score: <span class="font-semibold">${Math.min(100, structureCount * 20 + precisionCount * 3 + actionCount * 2)}%</span></div>
                 </div>
             </div>
             <div class="bg-purple-50 p-3 rounded-lg">
                 <h4 class="font-semibold text-purple-800 mb-1">Expected Impact:</h4>
-                <p class="text-sm">This optimized prompt should yield more consistent, accurate, and structured AI responses with reduced ambiguity and improved task completion rates.</p>
+                <p class="text-sm">This optimized prompt will execute with absolute precision, ensuring maximum reliability and performance under all expected conditions. The structure eliminates ambiguity, enforces error-free operation, and delivers consistent results according to the highest functional standards.</p>
+            </div>
+            <div class="bg-orange-50 p-3 rounded-lg">
+                <h4 class="font-semibold text-orange-800 mb-1">Compliance Status:</h4>
+                <p class="text-sm">✅ All constraints defined and enforced<br>✅ Success criteria clearly specified<br>✅ No assumptions beyond defined scope<br>✅ Brute-force reliability implemented</p>
             </div>
         </div>
     `;
     
     analysisContent.innerHTML = analysisHTML;
 }
-
 // Copy to clipboard
 function copyToClipboard() {
     if (!outputText.value) {

style.css

@@ -155,7 +155,6 @@ button:active::before {
     transform: translateY(-4px);
     box-shadow: 0 20px 25px -5px rgba(0, 0, 0, 0.1), 0 10px 10px -5px rgba(0, 0, 0, 0.04);
 }
-
 /* Pulse animation for optimization score */
 @keyframes scorePulse {
     0% {
@@ -173,6 +172,46 @@ button:active::before {
     animation: scorePulse 0.5s ease;
 }
 
+/* Robustness indicator styles */
+.robustness-indicator {
+    background: linear-gradient(135deg, #10b981 0%, #059669 100%);
+    color: white;
+    padding: 4px 12px;
+    border-radius: 12px;
+    font-size: 0.75rem;
+    font-weight: 600;
+    display: inline-block;
+    margin-top: 4px;
+}
+
+.compliance-badge {
+    background: linear-gradient(135deg, #6366f1 0%, #8b5cf6 100%);
+    color: white;
+    padding: 2px 8px;
+    border-radius: 8px;
+    font-size: 0.625rem;
+    font-weight: 500;
+    display: inline-block;
+    margin-left: 4px;
+}
+
+/* Enhanced textarea focus for precision */
+textarea:focus {
+    outline: none;
+    border-color: #6366f1;
+    box-shadow: 0 0 0 3px rgba(99, 102, 241, 0.1);
+}
+
+/* Structure validation highlight */
+.structure-valid {
+    border-color: #10b981 !important;
+    background-color: #f0fdf4 !important;
+}
+
+.structure-invalid {
+    border-color: #ef4444 !important;
+    background-color: #fef2f2 !important;
+}
 /* Responsive adjustments */
 @media (max-width: 768px) {
     .container {