Fix if/elif/else generation

project/blocks.txt

@@ -7,7 +7,7 @@ make_json(inputs(KEYN: value, FIELDN: value)) // N starts at 0; you can make as
 call_api(inputs(METHOD: "GET/POST/PUT/DELETE", URL: value, HEADERS: value)) // HEADERS is optional
 
 # Logic
-controls_if(inputs(IFN: value)) // N starts at 0; you can make as many N as you want
+controls_if(inputs(IF: value, IFELSEN0: value, ELSE)) // IF is REQUIRED (the condition). IFELSEN0, IFELSEN1, etc are OPTIONAL (additional else-if conditions). ELSE is OPTIONAL (no value needed, just include the word). DO NOT use input_name with controls_if creation; specify all conditions in the inputs. After creating, use input_name to place statements: "DO0" (IF then-statements), "DO1" (first ELSE-IF then-statements), "ELSE" (final else statements)
 logic_negate(inputs())
 logic_boolean(inputs(BOOL: "TRUE/FALSE"))
 logic_null(inputs())

project/chat.py

@@ -137,12 +137,6 @@ def delete_block(block_id):
 
 def create_block(block_spec, blockID=None, placement_type=None, input_name=None):
     try:
-        print(f"[CREATE REQUEST] Attempting to create block: {block_spec}")
-        if blockID:
-            print(f"[CREATE REQUEST] Placement type: {placement_type}, block ID: {blockID}")
-        if input_name:
-            print(f"[CREATE REQUEST] Input name: {input_name}")
-        
         # Generate a unique request ID
         import uuid
         request_id = str(uuid.uuid4())
@@ -160,7 +154,6 @@ def create_block(block_spec, blockID=None, placement_type=None, input_name=None)
         if input_name:
             queue_data["input_name"] = input_name
         creation_queue.put(queue_data)
-        print(f"[CREATE REQUEST] Added to queue with ID: {request_id}")
         
         # Wait for result with timeout
         import time
@@ -616,12 +609,33 @@ def create_gradio_interface():
     - Any block that outputs a result for something else to use
 
     ### How to Place Blocks
+    **IF/ELSE Blocks:**
+
+    The entire IF/ELSE structure must be created in one `create_block` call.
+
+    **Structure:**
+    `controls_if(inputs(IF: cond, IFELSEN0: cond2, IFELSEN1: cond3, ELSE))`
+
+    - `IF:` first condition (required)
+    - `IFELSEN#:` else-if conditions (optional)
+    - `ELSE` keyword (optional, no value)
+
+    **Do NOT:**
+    - Add ELSE or ELSE-IF later using `input_name`
+    - Give ELSE a value
+
+    **Correct placement after creation:**
+    - `input_name: "DO0"`: IF branch
+    - `input_name: "DO1"`: first ELSE-IF branch
+    - `input_name: "ELSE"`: ELSE branch
 
     **Placement types** - use `blockID` and `type` parameters:
     
     - `type: "under"` - For statement blocks inside containers. Create the container first, then create statement blocks using the container's ID.
       Example: Create a loop first, then use `blockID: loopID, type: "under"` to place code inside it.
       Also for stackable blocks: create one, get its ID, then create the next one with the previous block's ID and `type: "under"`.
+      **Optional: use `input_name` to specify which statement input to place the block in (e.g., "DO0", "DO1", "ELSE" for IF blocks).**
+      Example: `create_block(text_append(...), blockID: ifBlockID, type: "under", input_name: "DO0")` places the block in the first THEN branch of an IF block.
     
     - `type: "input"` - ONLY for value blocks placed in MCP output slots. Provide `input_name` with the output slot name (R0, R1, R2, etc).
       Example: `text(inputs(TEXT: "hello"))` with `type: "input", input_name: "R0"` places the text block in the MCP's first output slot.
@@ -756,7 +770,7 @@ def create_gradio_interface():
                     },
                     "input_name": {
                         "type": "string",
-                        "description": "Specific MCP input slot name when type is 'input'. Use 'RN', where N is the number of the output slot you want to put something into.",
+                        "description": "ONLY for two cases: placing value blocks into MCP output slots using 'R<N>', and placing statement blocks into specific branches of controls_if (DO0, DO1, ELSE). It must NEVER be used for anything else.",
                     },
                 },
                 "required": ["command"],

project/src/generators/chat.js

@@ -223,6 +223,75 @@ chatGenerator.blockToCode = function (block, opt_thisOnly) {
       if (num !== null && num !== undefined) {
         inputs.push(`NUM: ${num}`);
       }
+    } else if (blockType === 'controls_if') {
+      // Special handling for if/else blocks
+      // Extract all condition values in the proper format: IF, IFELSEN0, IFELSEN1, etc.
+      const ifCount = (block.inputList.filter(input => input.name && input.name.match(/^IF\d+$/)).length) || 1;
+
+      // Get the first IF condition
+      const if0Input = block.getInput('IF0');
+      if (if0Input && if0Input.connection) {
+        const condValue = this.valueToCode(block, 'IF0', this.ORDER_ATOMIC);
+        if (condValue) {
+          inputs.push(`IF: ${condValue}`);
+        }
+      }
+
+      // Get all additional IF conditions (IF1, IF2, etc.) as IFELSEN0, IFELSEN1, etc.
+      for (let i = 1; i < ifCount; i++) {
+        const ifInput = block.getInput('IF' + i);
+        if (ifInput && ifInput.connection) {
+          const condValue = this.valueToCode(block, 'IF' + i, this.ORDER_ATOMIC);
+          if (condValue) {
+            inputs.push(`IFELSEN${i - 1}: ${condValue}`);
+          }
+        }
+      }
+
+      // Check if ELSE exists (look for DO blocks and see if there's an ELSE)
+      const hasElse = block.getInput('ELSE') !== null && block.getInput('ELSE') !== undefined;
+
+      // If ELSE exists, add it to inputs (it's just a marker, no condition value)
+      if (hasElse) {
+        inputs.push(`ELSE`);
+      }
+
+      // Generate the controls_if call with conditions
+      let code = `${block.id} | ${blockType}(inputs(${inputs.join(', ')}))`;
+
+      // Now get all the statement blocks with proper formatting
+      // DO0, DO1, etc. are indented under the if
+      // ELSE blocks are labeled with "Else:" prefix
+      for (let i = 0; i < ifCount; i++) {
+        const doInput = block.getInput('DO' + i);
+        if (doInput) {
+          const doCode = this.statementToCode(block, 'DO' + i);
+          if (doCode) {
+            // Indent each line of the statement code
+            const indentedCode = doCode.split('\n').map(line => line ? '    ' + line : '').join('\n');
+            code += '\n' + indentedCode;
+          }
+        }
+      }
+
+      // Get ELSE block if it exists - format it with "Else:" label
+      if (hasElse) {
+        const elseCode = this.statementToCode(block, 'ELSE');
+        if (elseCode) {
+          code += '\nElse:\n';
+          // Indent each line of the else code
+          const indentedCode = elseCode.split('\n').map(line => line ? '    ' + line : '').join('\n');
+          code += indentedCode;
+        }
+      }
+
+      // Handle the next block in the sequence for statement chaining
+      if (!opt_thisOnly) {
+        const nextCode = this.scrub_(block, code, opt_thisOnly);
+        return nextCode;
+      }
+
+      return code + '\n';
     } else {
       // Generic field value extraction for other blocks
       // Get all inputs to check for fields
@@ -266,7 +335,14 @@ chatGenerator.blockToCode = function (block, opt_thisOnly) {
       if (input.type === Blockly.NEXT_STATEMENT && input.connection) {
         const statementCode = this.statementToCode(block, input.name);
         if (statementCode) {
-          statements += statementCode;
+          // Indent statement code (4 spaces) if this block will be a statement block
+          if (!block.outputConnection) {
+            // Only indent for statement blocks; value blocks handle their own formatting
+            const indentedCode = statementCode.split('\n').map(line => line ? '    ' + line : '').join('\n');
+            statements += indentedCode;
+          } else {
+            statements += statementCode;
+          }
         }
       }
     }

project/src/index.js

@@ -490,6 +490,69 @@ const setupUnifiedStream = () => {
                     }
                   }
                 }
+              } else if (blockType === 'controls_if') {
+                // Special handling for if/else blocks
+                // IF is required, IFELSEN0, IFELSEN1, etc are optional, ELSE is optional
+                // Each condition block goes into IF, IFELSEN0, IFELSEN1, etc inputs
+
+                // Count how many IF/IFELSEN conditions we have
+                let conditionCount = 0;
+                const conditionBlocks = {};
+                let hasElse = false;
+
+                console.log('[SSE CREATE] controls_if inputs:', inputs);
+
+                for (const [key, value] of Object.entries(inputs)) {
+                  if (key === 'IF') {
+                    conditionBlocks['IF'] = value;
+                  } else if (key.match(/^IFELSEN\d+$/)) {
+                    conditionBlocks[key] = value;
+                  } else if (key === 'ELSE' && value === true) {
+                    // ELSE is a marker with no value (set to true by parseInputs)
+                    console.log('[SSE CREATE] Detected ELSE marker');
+                    hasElse = true;
+                  }
+                }
+
+                console.log('[SSE CREATE] controls_if parsed: hasElse =', hasElse);
+
+                // Create inputs for each condition
+                if (conditionBlocks['IF']) {
+                  const ifValue = conditionBlocks['IF'];
+                  if (typeof ifValue === 'string' && ifValue.match(/^\w+\s*\(inputs\(/)) {
+                    const childBlock = parseAndCreateBlock(ifValue);
+                    const input = newBlock.getInput('IF0');
+                    if (input && input.connection && childBlock.outputConnection) {
+                      childBlock.outputConnection.connect(input.connection);
+                    }
+                  }
+                }
+
+                // Handle IFELSEN conditions
+                let elseIfCount = 0;
+                for (const [key, value] of Object.entries(conditionBlocks)) {
+                  const elseIfMatch = key.match(/^IFELSEN(\d+)$/);
+                  if (elseIfMatch) {
+                    const elseIfValue = value;
+                    if (typeof elseIfValue === 'string' && elseIfValue.match(/^\w+\s*\(inputs\(/)) {
+                      // Blockly uses a mutator to add IF/ELSE IF blocks, so we need to configure that
+                      // For now, just try to create the structure
+                      const childBlock = parseAndCreateBlock(elseIfValue);
+
+                      // The inputs will be IF1, IF2, etc. for additional conditions
+                      const ifInputName = 'IF' + (elseIfCount + 1);
+                      const input = newBlock.getInput(ifInputName);
+                      if (input && input.connection && childBlock.outputConnection) {
+                        childBlock.outputConnection.connect(input.connection);
+                      }
+                      elseIfCount++;
+                    }
+                  }
+                }
+
+                // Store these for later - we'll apply them after initSvg()
+                newBlock.pendingElseifCount_ = elseIfCount;
+                newBlock.pendingElseCount_ = hasElse ? 1 : 0;
               } else {
                 // Normal block handling
                 for (const [key, value] of Object.entries(inputs)) {
@@ -538,6 +601,45 @@ const setupUnifiedStream = () => {
             // Initialize the block (renders it)
             newBlock.initSvg();
 
+            // Apply pending controls_if mutations (must be after initSvg)
+            if (newBlock.type === 'controls_if' && (newBlock.pendingElseifCount_ > 0 || newBlock.pendingElseCount_ > 0)) {
+              console.log('[SSE CREATE] Applying controls_if mutation:', {
+                elseifCount: newBlock.pendingElseifCount_,
+                elseCount: newBlock.pendingElseCount_
+              });
+
+              // Use the loadExtraState method if available (Blockly's preferred way)
+              if (typeof newBlock.loadExtraState === 'function') {
+                const state = {};
+                if (newBlock.pendingElseifCount_ > 0) {
+                  state.elseIfCount = newBlock.pendingElseifCount_;
+                }
+                if (newBlock.pendingElseCount_ > 0) {
+                  state.hasElse = true;
+                }
+                console.log('[SSE CREATE] Using loadExtraState with:', state);
+                newBlock.loadExtraState(state);
+              } else {
+                // Fallback: Set the internal state variables and call updateShape_
+                newBlock.elseifCount_ = newBlock.pendingElseifCount_;
+                newBlock.elseCount_ = newBlock.pendingElseCount_;
+
+                if (typeof newBlock.updateShape_ === 'function') {
+                  console.log('[SSE CREATE] Calling updateShape_ on controls_if');
+                  newBlock.updateShape_();
+                }
+              }
+
+              // Verify the ELSE input was created
+              if (newBlock.pendingElseCount_ > 0) {
+                const elseInput = newBlock.getInput('ELSE');
+                console.log('[SSE CREATE] ELSE input after mutation:', elseInput);
+                if (!elseInput) {
+                  console.error('[SSE CREATE] ELSE input was NOT created!');
+                }
+              }
+            }
+
             // Only position the top-level block
             if (shouldPosition) {
               // Find a good position that doesn't overlap existing blocks
@@ -634,23 +736,29 @@ const setupUnifiedStream = () => {
             }
 
             // Handle the last key-value pair
-            if (currentKey && currentValue) {
+            if (currentKey) {
               currentKey = currentKey.trim();
-              currentValue = currentValue.trim();
-
-              // Parse the value
-              if (currentValue.match(/^\w+\s*\(inputs\(/)) {
-                // This is a nested block
-                result[currentKey] = currentValue;
-              } else if (currentValue.match(/^-?\d+(\.\d+)?$/)) {
-                // This is a number
-                result[currentKey] = parseFloat(currentValue);
-              } else if (currentValue === 'true' || currentValue === 'false') {
-                // This is a boolean
-                result[currentKey] = currentValue === 'true';
+
+              // If there's no value, this is a flag/marker (like ELSE)
+              if (!currentValue) {
+                result[currentKey] = true;  // Mark it as present
               } else {
-                // This is a string (remove quotes if present)
-                result[currentKey] = currentValue.replace(/^["']|["']$/g, '');
+                currentValue = currentValue.trim();
+
+                // Parse the value
+                if (currentValue.match(/^\w+\s*\(inputs\(/)) {
+                  // This is a nested block
+                  result[currentKey] = currentValue;
+                } else if (currentValue.match(/^-?\d+(\.\d+)?$/)) {
+                  // This is a number
+                  result[currentKey] = parseFloat(currentValue);
+                } else if (currentValue === 'true' || currentValue === 'false') {
+                  // This is a boolean
+                  result[currentKey] = currentValue === 'true';
+                } else {
+                  // This is a string (remove quotes if present)
+                  result[currentKey] = currentValue.replace(/^["']|["']$/g, '');
+                }
               }
             }
 
@@ -705,13 +813,10 @@ const setupUnifiedStream = () => {
               if (parentBlock) {
                 console.log('[SSE CREATE] Attaching to parent block:', data.blockID);
 
-                // Find an appropriate input to connect to
-                // Try common statement inputs first
-                const statementInputs = ['BODY', 'DO', 'THEN', 'ELSE', 'STACK'];
+                // If input_name is specified, try to connect to that specific input first
                 let connected = false;
-
-                for (const inputName of statementInputs) {
-                  const input = parentBlock.getInput(inputName);
+                if (data.input_name) {
+                  const input = parentBlock.getInput(data.input_name);
                   if (input && input.type === Blockly.NEXT_STATEMENT) {
                     // Check if something is already connected
                     if (input.connection && !input.connection.targetBlock()) {
@@ -719,8 +824,7 @@ const setupUnifiedStream = () => {
                       if (newBlock.previousConnection) {
                         input.connection.connect(newBlock.previousConnection);
                         connected = true;
-                        console.log('[SSE CREATE] Connected to input:', inputName);
-                        break;
+                        console.log('[SSE CREATE] Connected to specified input:', data.input_name);
                       }
                     } else if (input.connection && input.connection.targetBlock()) {
                       // Find the last block in the stack
@@ -732,8 +836,44 @@ const setupUnifiedStream = () => {
                       if (lastBlock.nextConnection && newBlock.previousConnection) {
                         lastBlock.nextConnection.connect(newBlock.previousConnection);
                         connected = true;
-                        console.log('[SSE CREATE] Connected to end of stack in input:', inputName);
-                        break;
+                        console.log('[SSE CREATE] Connected to end of stack in specified input:', data.input_name);
+                      }
+                    }
+                  } else {
+                    error = `Specified input '${data.input_name}' not found or is not a statement input`;
+                    console.warn('[SSE CREATE]', error);
+                  }
+                }
+
+                // If not connected via specified input_name, try common statement inputs
+                if (!connected) {
+                  const statementInputs = ['BODY', 'DO', 'THEN', 'ELSE', 'STACK'];
+
+                  for (const inputName of statementInputs) {
+                    const input = parentBlock.getInput(inputName);
+                    if (input && input.type === Blockly.NEXT_STATEMENT) {
+                      // Check if something is already connected
+                      if (input.connection && !input.connection.targetBlock()) {
+                        // Connect directly
+                        if (newBlock.previousConnection) {
+                          input.connection.connect(newBlock.previousConnection);
+                          connected = true;
+                          console.log('[SSE CREATE] Connected to input:', inputName);
+                          break;
+                        }
+                      } else if (input.connection && input.connection.targetBlock()) {
+                        // Find the last block in the stack
+                        let lastBlock = input.connection.targetBlock();
+                        while (lastBlock.nextConnection && lastBlock.nextConnection.targetBlock()) {
+                          lastBlock = lastBlock.nextConnection.targetBlock();
+                        }
+                        // Connect to the end of the stack
+                        if (lastBlock.nextConnection && newBlock.previousConnection) {
+                          lastBlock.nextConnection.connect(newBlock.previousConnection);
+                          connected = true;
+                          console.log('[SSE CREATE] Connected to end of stack in input:', inputName);
+                          break;
+                        }
                       }
                     }
                   }