Upload app.py with huggingface_hub

app.py

@@ -284,6 +284,19 @@ condition.to(lowPriority, 1);   // FALSE path (output index 1)
 6. Use proper n8n expression syntax: ={{{{$json.fieldName}}}}
 7. Only use nodes from the list above
 8. Keep workflows clean and maintainable
+9. **ALWAYS add connection calls** - Every node must be connected with `.to()`
+10. **Keep parameters simple** - Avoid complex nested formulas
+11. **No Excel formulas** - Don't use DATE(), IF(), FILTER(), etc. Use n8n expressions only
+12. **Complete the code** - Include all connection statements at the end
+
+## CRITICAL RULES:
+
+- ❌ **NEVER** use Excel-like formulas (DATE, IF, FILTER, MIN, MAX, etc.)
+- ❌ **NEVER** leave code incomplete - always add connections
+- ❌ **NEVER** use node types not in the list above (e.g., no `apiRequest`)
+- ✅ **ALWAYS** connect all nodes with `.to()` calls
+- ✅ **ALWAYS** use simple, valid JSON for parameters
+- ✅ **ALWAYS** use n8n expressions like `={{{{$json.field}}}}` for dynamic values
 
 Generate ONLY the TypeScript DSL code, wrapped in ```typescript code blocks.
 
@@ -388,30 +401,46 @@ def clean_n8n_expressions(obj):
     return obj
 
 def parse_js_object(js_obj_str):
-    """Convert JavaScript object notation to Python dict"""
+    """Convert JavaScript object notation to Python dict with robust error handling"""
     if not js_obj_str or js_obj_str.strip() == "{}":
         return {}
 
+    # Try direct JSON parsing first
     try:
-        # First try direct JSON parsing
         parsed = json.loads(js_obj_str)
         return clean_n8n_expressions(parsed)
     except:
         pass
 
+    # Try with ast.literal_eval for Python-like syntax
     try:
-        # Convert JS object notation to JSON
-        # Replace single quotes with double quotes (but preserve n8n expressions)
-        json_str = js_obj_str.replace("'", '"')
-
-        # Add quotes around unquoted keys (e.g., {path: "data"} -> {"path": "data"})
-        json_str = re.sub(r'(\w+):', r'"\1":', json_str)
+        import ast
+        # Replace JS booleans with Python booleans
+        python_str = js_obj_str.replace('true', 'True').replace('false', 'False').replace('null', 'None')
+        parsed = ast.literal_eval(python_str)
+        if isinstance(parsed, dict):
+            return clean_n8n_expressions(parsed)
+    except:
+        pass
 
-        # Parse the JSON
-        parsed = json.loads(json_str)
-        return clean_n8n_expressions(parsed)
+    # Last resort: Try manual key-value extraction
+    try:
+        # Extract simple key-value pairs only
+        result = {}
+        # Match simple patterns: "key": "value" or key: "value"
+        pattern = r'["\']?(\w+)["\']?\s*:\s*["\']([^"\']*)["\']'
+        matches = re.findall(pattern, js_obj_str)
+        for key, value in matches:
+            result[key] = value
+
+        if result:
+            return clean_n8n_expressions(result)
+
+        # If no matches, return empty dict to avoid breaking the workflow
+        print(f"Warning: Could not parse parameters, using empty dict. Input: {js_obj_str[:100]}...")
+        return {}
     except Exception as e:
-        print(f"Warning: Could not parse parameters '{js_obj_str}': {e}")
+        print(f"Warning: Complete parse failure for parameters: {str(e)[:100]}")
         return {}
 
 def sanitize_n8n_parameters(node_type, parameters):
@@ -478,9 +507,35 @@ def extract_balanced_braces(text, start_pos):
 
     return None
 
+def validate_dsl_code(typescript_code):
+    """Validate DSL code has minimum required structure"""
+    if not typescript_code or len(typescript_code.strip()) < 50:
+        return False, "Generated code is too short or empty"
+
+    if "workflow.add(" not in typescript_code:
+        return False, "No nodes found in generated code"
+
+    # Count nodes and connections
+    node_count = len(re.findall(r'const\s+\w+\s*=\s*workflow\.add\(', typescript_code))
+    connection_count = len(re.findall(r'\.to\(', typescript_code))
+
+    if node_count == 0:
+        return False, "No valid nodes found"
+
+    if node_count > 1 and connection_count == 0:
+        return False, f"Found {node_count} nodes but no connections - code may be incomplete"
+
+    return True, "OK"
+
 def convert_to_n8n_json(typescript_code):
     """Convert TypeScript DSL to n8n JSON format"""
 
+    # Validate DSL first
+    is_valid, error_msg = validate_dsl_code(typescript_code)
+    if not is_valid:
+        print(f"⚠️  DSL Validation Warning: {error_msg}")
+        # Continue anyway but warn user
+
     nodes = []
     connections = {}
     workflow_name = "Generated Workflow"