Add workspace language

project/src/generators/chat.js

@@ -0,0 +1,245 @@
+import * as Blockly from 'blockly';
+
+// Create a custom generator for the chat/AI language
+class ChatGenerator extends Blockly.Generator {
+  constructor(name) {
+    super(name);
+    // Custom order definitions for the chat language if needed
+    this.ORDER_ATOMIC = 0;
+  }
+
+  // Override scrub_ to handle how blocks are joined
+  scrub_(block, code, thisOnly) {
+    const nextBlock = block.nextConnection && block.nextConnection.targetBlock();
+    let nextCode = '';
+    if (nextBlock) {
+      nextCode = this.blockToCode(nextBlock);
+    }
+    return code + nextCode;
+  }
+}
+
+// Create an instance of the chat generator
+export const chatGenerator = new ChatGenerator('Chat');
+
+// Export forBlock for custom block definitions
+export const forBlock = Object.create(null);
+
+/*
+
+This file is for the secondary code generator.
+It is not meant to be shown to the user, but rather to communicate the state of the workspace to an AI chat assistant in a simplistic text format.
+
+*/
+
+forBlock['create_mcp'] = function (block, generator) {
+  const inputParams = [];
+  const outputParams = [];
+  let i = 0;
+
+  // Build list of input parameters with types
+  while (block.getInput('X' + i)) {
+    const input = block.getInput('X' + i);
+    if (input && input.connection && input.connection.targetBlock()) {
+      const paramName = (block.inputNames_ && block.inputNames_[i]) || ('arg' + i);
+      const type = (block.inputTypes_ && block.inputTypes_[i]) || 'string';
+      inputParams.push(`${paramName}: ${type}`);
+    }
+    i++;
+  }
+
+  // Build list of output parameters with values (not types)
+  if (block.outputCount_ && block.outputCount_ > 0 && block.getInput('R0')) {
+    for (let r = 0; r < block.outputCount_; r++) {
+      const outputName = (block.outputNames_ && block.outputNames_[r]) || `result${r}`;
+      let returnValue = generator.valueToCode(block, 'R' + r, chatGenerator.ORDER_ATOMIC) || 'None';
+      
+      // Replace placeholder args with actual names
+      if (returnValue && block.inputNames_) {
+        for (let j = 0; j < block.inputNames_.length; j++) {
+          const paramName = block.inputNames_[j];
+          returnValue = returnValue.replace(new RegExp(`arg${j}\\b`, 'g'), paramName);
+        }
+      }
+      
+      outputParams.push(`${outputName}: ${returnValue}`);
+    }
+  }
+
+  // Main function body
+  let body = generator.statementToCode(block, 'BODY');
+
+  // Construct the create_mcp call with inputs and outputs
+  let code = `create_mcp(inputs(${inputParams.join(', ')}), outputs(${outputParams.join(', ')}))\n`;
+
+  // Add the function body
+  if (body) {
+    code += body;
+  }
+
+  return code;
+};
+
+forBlock['func_def'] = function (block, generator) {
+  const name = block.getFieldValue('NAME');
+  const inputParams = [];
+  const outputParams = [];
+  let i = 0;
+
+  // Build list of input parameters with types
+  while (block.getInput('X' + i)) {
+    const input = block.getInput('X' + i);
+    if (input && input.connection && input.connection.targetBlock()) {
+      const paramName = (block.inputNames_ && block.inputNames_[i]) || ('arg' + i);
+      const type = (block.inputTypes_ && block.inputTypes_[i]) || 'string';
+      inputParams.push(`${paramName}: ${type}`);
+    }
+    i++;
+  }
+
+  // Build list of output parameters with values (not types)
+  if (block.outputCount_ && block.outputCount_ > 0 && block.getInput('R0')) {
+    for (let r = 0; r < block.outputCount_; r++) {
+      const outputName = (block.outputNames_ && block.outputNames_[r]) || `output${r}`;
+      let returnValue = generator.valueToCode(block, 'R' + r, chatGenerator.ORDER_ATOMIC) || 'None';
+      
+      // Replace placeholder args with actual names
+      if (returnValue && block.inputNames_) {
+        for (let j = 0; j < block.inputNames_.length; j++) {
+          const paramName = block.inputNames_[j];
+          returnValue = returnValue.replace(new RegExp(`arg${j}\\b`, 'g'), paramName);
+        }
+      }
+      
+      outputParams.push(`${outputName}: ${returnValue}`);
+    }
+  }
+
+  // Main function body
+  let body = generator.statementToCode(block, 'BODY');
+
+  // Construct the func_def call with inputs and outputs
+  let code = `${name}(inputs(${inputParams.join(', ')}), outputs(${outputParams.join(', ')}))\n`;
+
+  // Add the function body
+  if (body) {
+    code += body;
+  }
+
+  return code;
+};
+
+// Handler for input reference blocks
+forBlock['input_reference'] = function(block, generator) {
+  const varName = block.getFieldValue('VARNAME') || 
+                  block.type.replace('input_reference_', '') || 
+                  'unnamed_arg';
+  // Value blocks must return a tuple: [code, order]
+  return [varName, chatGenerator.ORDER_ATOMIC];
+};
+
+// Register the forBlock definitions with the chat generator
+Object.assign(chatGenerator.forBlock, forBlock);
+
+// Override blockToCode to provide a catch-all handler
+const originalBlockToCode = chatGenerator.blockToCode.bind(chatGenerator);
+chatGenerator.blockToCode = function(block, opt_thisOnly) {
+  // Null check
+  if (!block) {
+    return '';
+  }
+  
+  // Check if it's an input reference block type
+  if (block.type.startsWith('input_reference_')) {
+    const varName = block.getFieldValue('VARNAME') || 
+                    block.type.replace('input_reference_', '') || 
+                    'unnamed_arg';
+    // Value blocks must return a tuple: [code, order]
+    return [varName, this.ORDER_ATOMIC];
+  }
+  
+  // Try the normal generation first
+  try {
+    return originalBlockToCode(block, opt_thisOnly);
+  } catch (e) {
+    // Catch-all handler for blocks without specific generators
+    const blockType = block.type;
+    const inputs = [];
+    
+    // Special handling for common blocks with field values
+    if (blockType === 'text') {
+      const text = block.getFieldValue('TEXT');
+      if (text !== null && text !== undefined) {
+        inputs.push(`TEXT: "${text}"`);
+      }
+    } else if (blockType === 'math_number') {
+      const num = block.getFieldValue('NUM');
+      if (num !== null && num !== undefined) {
+        inputs.push(`NUM: ${num}`);
+      }
+    } else {
+      // Generic field value extraction for other blocks
+      // Get all inputs to check for fields
+      const inputList = block.inputList || [];
+      for (const input of inputList) {
+        // Check fields in each input
+        if (input.fieldRow) {
+          for (const field of input.fieldRow) {
+            if (field && field.name && field.getValue) {
+              const value = field.getValue();
+              if (value !== null && value !== undefined && value !== '') {
+                // Format the value appropriately
+                const formattedValue = typeof value === 'string' ? `"${value}"` : value;
+                inputs.push(`${field.name}: ${formattedValue}`);
+              }
+            }
+          }
+        }
+      }
+    }
+    
+    // Then get all value inputs (connected blocks)
+    const inputList = block.inputList || [];
+    for (const input of inputList) {
+      if (input.type === Blockly.inputs.inputTypes.VALUE && input.connection) {
+        const inputName = input.name;
+        const inputValue = this.valueToCode(block, inputName, this.ORDER_ATOMIC);
+        
+        if (inputValue) {
+          inputs.push(`${inputName}: ${inputValue}`);
+        }
+      }
+    }
+    
+    // Generate the standard format: name(inputs(...))
+    const code = `${blockType}(inputs(${inputs.join(', ')}))`;
+    
+    // Handle statement inputs (for blocks that have a body)
+    let statements = '';
+    for (const input of inputList) {
+      if (input.type === Blockly.inputs.inputTypes.STATEMENT && input.connection) {
+        const statementCode = this.statementToCode(block, input.name);
+        if (statementCode) {
+          statements += statementCode;
+        }
+      }
+    }
+    
+    // Return appropriate format based on whether it's a value or statement block
+    if (block.outputConnection) {
+      // This is a value block (can be plugged into inputs)
+      return [code, this.ORDER_ATOMIC];
+    } else {
+      // This is a statement block (has prev/next connections)
+      const fullCode = code + (statements ? '\n' + statements : '');
+      
+      // Handle the next block in the sequence if not opt_thisOnly
+      if (!opt_thisOnly) {
+        const nextCode = this.scrub_(block, fullCode, opt_thisOnly);
+        return nextCode;
+      }
+      
+      return fullCode + '\n';
+    }
+  }
+};

project/src/index.js

@@ -2,6 +2,7 @@ import * as Blockly from 'blockly';
 import { blocks } from './blocks/text';
 import { forBlock } from './generators/python';
 import { pythonGenerator } from 'blockly/python';
+import { chatGenerator, forBlock as chatForBlock } from './generators/chat';
 import { save, load } from './serialization';
 import { toolbox } from './toolbox';
 import '@blockly/toolbox-search';
@@ -12,6 +13,9 @@ import './index.css';
 Blockly.common.defineBlocks(blocks);
 Object.assign(pythonGenerator.forBlock, forBlock);
 
+// Register chat generator blocks
+Object.assign(chatGenerator.forBlock, chatForBlock);
+
 // Set up UI elements and inject Blockly
 const blocklyDiv = document.getElementById('blocklyDiv');
 
@@ -187,6 +191,26 @@ const updateCode = () => {
     });
 };
 
+// Update function for the Chat generator (AI Chat tab)
+const updateChatCode = () => {
+  let code = chatGenerator.workspaceToCode(ws);
+  const codeEl = document.querySelector('#aichatCode code');
+
+  // You can add any chat-specific preprocessing here
+  // For example, adding headers or formatting
+  
+  if (codeEl) {
+    codeEl.textContent = code;
+  }
+
+  // Optionally send to a different endpoint or process differently
+  // fetch("http://127.0.0.1:7860/update_chat_code", {
+  //   method: "POST",
+  //   headers: { "Content-Type": "application/json" },
+  //   body: JSON.stringify({ code }),
+  // });
+};
+
 try {
   load(ws);
 
@@ -250,6 +274,7 @@ if (existingMcpBlocks.length === 0) {
 }
 
 updateCode();
+updateChatCode();
 
 ws.addChangeListener((e) => {
   if (e.isUiEvent) return;
@@ -318,4 +343,5 @@ ws.addChangeListener((e) => {
     return;
   }
   updateCode();
+  updateChatCode();
 });