genai-lite 0.2.1 → 0.3.1

package/dist/prompting/template.js

@@ -15,9 +15,17 @@ exports.renderTemplate = renderTemplate;
  * - Simple variable substitution: {{ variableName }}
  * - Conditional rendering: {{ condition ? `true result` : `false result` }}
  * - Conditional with only true branch: {{ condition ? `true result` }}
+ * - Logical operators in conditions:
+ *   - NOT: {{ !isDisabled ? `enabled` : `disabled` }}
+ *   - AND: {{ hasPermission && isActive ? `show` : `hide` }}
+ *   - OR: {{ isAdmin || isOwner ? `allow` : `deny` }}
+ *   - Combined: {{ !isDraft && isPublished ? `public` : `private` }}
  * - Multi-line strings in backticks
  * - Intelligent newline handling (removes empty lines when result is empty)
  *
+ * Note: Logical operators support up to 2 operands. Complex expressions
+ * (parentheses, mixing && and ||, or 3+ operands) are not supported.
+ *
  * @param template The template string containing placeholders
  * @param variables Object containing variable values
  * @returns The rendered template string
@@ -87,6 +95,53 @@ function renderTemplate(template, variables) {
     }
     return result;
 }
+/**
+ * Evaluates a condition string that may contain logical operators (&&, ||, !)
+ * Supports:
+ * - Simple variable: varName
+ * - Negation: !varName
+ * - AND: varName1 && varName2, !varName1 && varName2
+ * - OR: varName1 || varName2, !varName1 || varName2
+ *
+ * Does NOT support:
+ * - Parentheses for grouping
+ * - Mixing && and || in same expression
+ * - More than 2 operands
+ */
+function evaluateCondition(condition, variables) {
+    condition = condition.trim();
+    // Check for AND operator
+    if (condition.includes('&&')) {
+        const parts = condition.split('&&').map(p => p.trim());
+        if (parts.length !== 2) {
+            // Fallback to simple variable lookup for complex expressions
+            return !!variables[condition];
+        }
+        return evaluateSimpleCondition(parts[0], variables) && evaluateSimpleCondition(parts[1], variables);
+    }
+    // Check for OR operator
+    if (condition.includes('||')) {
+        const parts = condition.split('||').map(p => p.trim());
+        if (parts.length !== 2) {
+            // Fallback to simple variable lookup for complex expressions
+            return !!variables[condition];
+        }
+        return evaluateSimpleCondition(parts[0], variables) || evaluateSimpleCondition(parts[1], variables);
+    }
+    // Simple condition (possibly with negation)
+    return evaluateSimpleCondition(condition, variables);
+}
+/**
+ * Evaluates a simple condition that may have a ! prefix
+ */
+function evaluateSimpleCondition(condition, variables) {
+    condition = condition.trim();
+    if (condition.startsWith('!')) {
+        const varName = condition.substring(1).trim();
+        return !variables[varName];
+    }
+    return !!variables[condition];
+}
 function processExpression(expression, variables, leadingNewline, trailingNewline) {
     const conditionalMarkerIndex = expression.indexOf('?');
     let result;
@@ -104,7 +159,7 @@ function processExpression(expression, variables, leadingNewline, trailingNewlin
     }
     else {
         // --- Conditional 'ternary' substitution ---
-        const conditionKey = expression.substring(0, conditionalMarkerIndex).trim();
+        const conditionStr = expression.substring(0, conditionalMarkerIndex).trim();
         const rest = expression.substring(conditionalMarkerIndex + 1).trim();
         // Parse ternary expression with backtick-delimited strings
         // We need to handle nested {{ }} within backticks
@@ -165,8 +220,31 @@ function processExpression(expression, variables, leadingNewline, trailingNewlin
             }
         }
         else {
-            // Fallback to old quote-based parsing for backward compatibility
-            const elseMarkerIndex = rest.indexOf(':');
+            // Fallback to quote-based parsing for backward compatibility
+            // Need to find the ':' that separates true/false parts, not one inside quotes
+            let elseMarkerIndex = -1;
+            let inSingleQuote = false;
+            let inDoubleQuote = false;
+            for (let i = 0; i < rest.length; i++) {
+                const char = rest[i];
+                const prevChar = i > 0 ? rest[i - 1] : '';
+                // Track quote state (ignoring escaped quotes)
+                if (char === "'" && prevChar !== '\\') {
+                    if (!inDoubleQuote) {
+                        inSingleQuote = !inSingleQuote;
+                    }
+                }
+                else if (char === '"' && prevChar !== '\\') {
+                    if (!inSingleQuote) {
+                        inDoubleQuote = !inDoubleQuote;
+                    }
+                }
+                else if (char === ':' && !inSingleQuote && !inDoubleQuote) {
+                    // Found the separator outside of quotes
+                    elseMarkerIndex = i;
+                    break;
+                }
+            }
             if (elseMarkerIndex === -1) {
                 trueText = rest;
             }
@@ -176,15 +254,20 @@ function processExpression(expression, variables, leadingNewline, trailingNewlin
             }
             // Remove quotes from the start and end of the text parts
             const unquote = (text) => {
-                if ((text.startsWith('"') && text.endsWith('"')) || (text.startsWith("'") && text.endsWith("'"))) {
-                    return text.slice(1, -1);
+                if (text.startsWith('"') && text.endsWith('"')) {
+                    // Remove the outer double quotes and unescape inner quotes
+                    return text.slice(1, -1).replace(/\\"/g, '"');
+                }
+                else if (text.startsWith("'") && text.endsWith("'")) {
+                    // Remove the outer single quotes and unescape inner quotes
+                    return text.slice(1, -1).replace(/\\'/g, "'");
                 }
                 return text;
             };
             trueText = unquote(trueText);
             falseText = unquote(falseText);
         }
-        const conditionValue = !!variables[conditionKey]; // Evaluate truthiness
+        const conditionValue = evaluateCondition(conditionStr, variables);
         result = conditionValue ? trueText : falseText;
         // Recursively process the result to handle nested variables
         if (result.includes('{{')) {

package/dist/prompting/template.test.js

@@ -131,4 +131,120 @@ End
         const result = (0, template_1.renderTemplate)(template, { any: 'value' });
         expect(result).toBe('Just plain text');
     });
+    describe('colon handling in quoted strings', () => {
+        it('should handle colon in double-quoted true branch', () => {
+            const template = '{{ isDraft ? "Note: This is a draft" : "Published" }}';
+            expect((0, template_1.renderTemplate)(template, { isDraft: true })).toBe('Note: This is a draft');
+            expect((0, template_1.renderTemplate)(template, { isDraft: false })).toBe('Published');
+        });
+        it('should handle colon in single-quoted true branch', () => {
+            const template = "{{ isDraft ? 'Note: This is a draft' : 'Published' }}";
+            expect((0, template_1.renderTemplate)(template, { isDraft: true })).toBe('Note: This is a draft');
+            expect((0, template_1.renderTemplate)(template, { isDraft: false })).toBe('Published');
+        });
+        it('should handle colon in both branches', () => {
+            const template = '{{ isDraft ? "Status: Draft" : "Status: Published" }}';
+            expect((0, template_1.renderTemplate)(template, { isDraft: true })).toBe('Status: Draft');
+            expect((0, template_1.renderTemplate)(template, { isDraft: false })).toBe('Status: Published');
+        });
+        it('should handle multiple colons in quoted strings', () => {
+            const template = '{{ showTime ? "Time: 10:30:45" : "Time: Not available" }}';
+            expect((0, template_1.renderTemplate)(template, { showTime: true })).toBe('Time: 10:30:45');
+            expect((0, template_1.renderTemplate)(template, { showTime: false })).toBe('Time: Not available');
+        });
+        it('should handle escaped quotes with colons', () => {
+            const template = '{{ useAdvanced ? "He said: \\"Hello\\"" : "Simple greeting" }}';
+            expect((0, template_1.renderTemplate)(template, { useAdvanced: true })).toBe('He said: "Hello"');
+        });
+        it('should handle mixed quote types', () => {
+            const template = `{{ showBoth ? "Bob's message: 'Hi there'" : 'Alice said: "Hello"' }}`;
+            expect((0, template_1.renderTemplate)(template, { showBoth: true })).toBe("Bob's message: 'Hi there'");
+            expect((0, template_1.renderTemplate)(template, { showBoth: false })).toBe('Alice said: "Hello"');
+        });
+        it('should handle URL-like strings with colons', () => {
+            const template = '{{ useHttps ? "https://example.com" : "http://example.com" }}';
+            expect((0, template_1.renderTemplate)(template, { useHttps: true })).toBe('https://example.com');
+            expect((0, template_1.renderTemplate)(template, { useHttps: false })).toBe('http://example.com');
+        });
+        it('should work with backtick syntax (regression test)', () => {
+            const template = '{{ isDraft ? `Note: This is a draft` : `Status: Published` }}';
+            expect((0, template_1.renderTemplate)(template, { isDraft: true })).toBe('Note: This is a draft');
+            expect((0, template_1.renderTemplate)(template, { isDraft: false })).toBe('Status: Published');
+        });
+        it('should handle no false branch with colon in true branch', () => {
+            const template = '{{ showNote ? "Note: Important information" }}';
+            expect((0, template_1.renderTemplate)(template, { showNote: true })).toBe('Note: Important information');
+            expect((0, template_1.renderTemplate)(template, { showNote: false })).toBe('');
+        });
+        it('should handle colons with logical operators', () => {
+            const template = '{{ isActive && hasAccess ? "Status: Active" : "Status: Inactive" }}';
+            expect((0, template_1.renderTemplate)(template, { isActive: true, hasAccess: true })).toBe('Status: Active');
+            expect((0, template_1.renderTemplate)(template, { isActive: false, hasAccess: true })).toBe('Status: Inactive');
+        });
+    });
+    describe('logical operators in conditions', () => {
+        it('should handle NOT operator (!)', () => {
+            const template = '{{ !isDisabled ? `Enabled` : `Disabled` }}';
+            expect((0, template_1.renderTemplate)(template, { isDisabled: false })).toBe('Enabled');
+            expect((0, template_1.renderTemplate)(template, { isDisabled: true })).toBe('Disabled');
+        });
+        it('should handle AND operator (&&)', () => {
+            const template = '{{ hasPermission && isActive ? `Show button` : `Hide button` }}';
+            expect((0, template_1.renderTemplate)(template, { hasPermission: true, isActive: true })).toBe('Show button');
+            expect((0, template_1.renderTemplate)(template, { hasPermission: true, isActive: false })).toBe('Hide button');
+            expect((0, template_1.renderTemplate)(template, { hasPermission: false, isActive: true })).toBe('Hide button');
+            expect((0, template_1.renderTemplate)(template, { hasPermission: false, isActive: false })).toBe('Hide button');
+        });
+        it('should handle OR operator (||)', () => {
+            const template = '{{ isAdmin || isOwner ? `Has access` : `No access` }}';
+            expect((0, template_1.renderTemplate)(template, { isAdmin: true, isOwner: false })).toBe('Has access');
+            expect((0, template_1.renderTemplate)(template, { isAdmin: false, isOwner: true })).toBe('Has access');
+            expect((0, template_1.renderTemplate)(template, { isAdmin: true, isOwner: true })).toBe('Has access');
+            expect((0, template_1.renderTemplate)(template, { isAdmin: false, isOwner: false })).toBe('No access');
+        });
+        it('should handle NOT with AND', () => {
+            const template = '{{ !isDraft && isPublished ? `Show public` : `Hide` }}';
+            expect((0, template_1.renderTemplate)(template, { isDraft: false, isPublished: true })).toBe('Show public');
+            expect((0, template_1.renderTemplate)(template, { isDraft: true, isPublished: true })).toBe('Hide');
+        });
+        it('should handle NOT with OR', () => {
+            const template = '{{ !isBlocked || isAdmin ? `Allow` : `Deny` }}';
+            expect((0, template_1.renderTemplate)(template, { isBlocked: false, isAdmin: false })).toBe('Allow');
+            expect((0, template_1.renderTemplate)(template, { isBlocked: true, isAdmin: true })).toBe('Allow');
+            expect((0, template_1.renderTemplate)(template, { isBlocked: true, isAdmin: false })).toBe('Deny');
+        });
+        it('should handle NOT on both sides of AND', () => {
+            const template = '{{ !isLoading && !hasError ? `Ready` : `Not ready` }}';
+            expect((0, template_1.renderTemplate)(template, { isLoading: false, hasError: false })).toBe('Ready');
+            expect((0, template_1.renderTemplate)(template, { isLoading: true, hasError: false })).toBe('Not ready');
+            expect((0, template_1.renderTemplate)(template, { isLoading: false, hasError: true })).toBe('Not ready');
+        });
+        it('should handle whitespace around operators', () => {
+            const template = '{{  !isDisabled   &&   isVisible  ?  `Show`  :  `Hide`  }}';
+            expect((0, template_1.renderTemplate)(template, { isDisabled: false, isVisible: true })).toBe('Show');
+        });
+        it('should handle undefined variables in logical expressions', () => {
+            const template = '{{ undefinedVar && definedVar ? `Both true` : `At least one false` }}';
+            expect((0, template_1.renderTemplate)(template, { definedVar: true })).toBe('At least one false');
+        });
+        it('should handle falsy values in logical expressions', () => {
+            const template = '{{ nullVar || zero ? `Has truthy` : `All falsy` }}';
+            expect((0, template_1.renderTemplate)(template, { nullVar: null, zero: 0 })).toBe('All falsy');
+            const template2 = '{{ emptyString || text ? `Has truthy` : `All falsy` }}';
+            expect((0, template_1.renderTemplate)(template2, { emptyString: '', text: 'hello' })).toBe('Has truthy');
+        });
+        it('should fallback to simple lookup for complex expressions', () => {
+            // More than 2 operands should fallback
+            const template = '{{ a && b && c ? `True` : `False` }}';
+            const result = (0, template_1.renderTemplate)(template, { 'a && b && c': true });
+            expect(result).toBe('True');
+        });
+        it('should handle nested templates with logical operators', () => {
+            const template = '{{ showDetails && hasData ? `Details: {{data}}` : `No details` }}';
+            expect((0, template_1.renderTemplate)(template, { showDetails: true, hasData: true, data: 'Important info' }))
+                .toBe('Details: Important info');
+            expect((0, template_1.renderTemplate)(template, { showDetails: false, hasData: true, data: 'Important info' }))
+                .toBe('No details');
+        });
+    });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genai-lite",
-  "version": "0.2.1",
+  "version": "0.3.1",
   "description": "A lightweight, portable toolkit for interacting with various Generative AI APIs.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",