@adminide-stack/form-builder-core 5.1.4-alpha.105

package/lib/inngest/monacoAutocompleteIntegration.js

@@ -0,0 +1,341 @@
+import {getStepCompletionContext,getStepTypeDefinitions}from'./stepGenerator.js';/**
+ * Monaco Editor Integration for JavaScript Autocomplete
+ *
+ * Integrates with the js-autocomplete-extension via command execution
+ * to provide intelligent code completions in step function editors.
+ */
+/**
+ * Setup JavaScript autocomplete for Monaco Editor using extension commands
+ *
+ * @param monaco Monaco editor instance
+ * @param options Configuration options
+ * @param commandService Service for executing extension commands
+ */
+async function setupMonacoAutocomplete(monaco, options = {}, commandService) {
+  const {
+    enableInngestContext = true,
+    customScope = [],
+    enableHoverInfo = true
+  } = options;
+  const commands = commandService || options.commandService;
+  if (!commands) {
+    console.warn('No command service provided, autocomplete will not be available');
+    return;
+  }
+  // Build scope context
+  const scope = [...customScope];
+  if (enableInngestContext) {
+    scope.push('step', 'event', 'run', 'sleep', 'sendEvent', 'waitForEvent');
+  }
+  // Configure TypeScript/JavaScript compiler options to prevent worker errors
+  const compilerOptions = {
+    target: monaco.languages.typescript.ScriptTarget.ES2020,
+    allowNonTsExtensions: true,
+    moduleResolution: monaco.languages.typescript.ModuleResolutionKind.NodeJs,
+    module: monaco.languages.typescript.ModuleKind.CommonJS,
+    noEmit: true,
+    esModuleInterop: true,
+    allowJs: true,
+    checkJs: false,
+    noSemanticValidation: false,
+    noSyntaxValidation: false
+  };
+  // Set compiler options for both JavaScript and TypeScript
+  monaco.languages.typescript.javascriptDefaults.setCompilerOptions(compilerOptions);
+  monaco.languages.typescript.typescriptDefaults.setCompilerOptions(compilerOptions);
+  // Configure diagnostics options to prevent unnecessary worker calls
+  monaco.languages.typescript.javascriptDefaults.setDiagnosticsOptions({
+    noSemanticValidation: false,
+    noSyntaxValidation: false,
+    diagnosticCodesToIgnore: [1108] // Ignore "A 'return' statement can only be used within a function body"
+  });
+  monaco.languages.typescript.typescriptDefaults.setDiagnosticsOptions({
+    noSemanticValidation: false,
+    noSyntaxValidation: false
+  });
+  // Disable eager model sync to prevent worker trying to access non-existent models
+  monaco.languages.typescript.javascriptDefaults.setEagerModelSync(false);
+  monaco.languages.typescript.typescriptDefaults.setEagerModelSync(false);
+  // Register completion provider for JavaScript
+  monaco.languages.registerCompletionItemProvider('javascript', {
+    triggerCharacters: ['.', ' '],
+    provideCompletionItems: async (model, position) => {
+      try {
+        const text = model.getValue();
+        const offset = model.getOffsetAt(position);
+        // Call the autocomplete extension command
+        const result = await commands.executeCommand({
+          command: 'jsAutocomplete.getCompletions',
+          arguments: [text, offset, scope.length > 0 ? scope : undefined]
+        });
+        if (!result || !result.completions) {
+          return {
+            suggestions: []
+          };
+        }
+        // Convert to Monaco completion items
+        const suggestions = result.completions.map(completion => ({
+          label: completion.name,
+          kind: determineCompletionKind(completion.type, monaco),
+          documentation: formatDocumentation(completion),
+          insertText: completion.name,
+          detail: completion.type || 'any',
+          sortText: getSortText(completion)
+        }));
+        return {
+          suggestions,
+          incomplete: result.isIncomplete || false
+        };
+      } catch (error) {
+        console.error('Autocomplete error:', error);
+        return {
+          suggestions: []
+        };
+      }
+    },
+    resolveCompletionItem: async item => {
+      if (!enableHoverInfo) {
+        return item;
+      }
+      try {
+        // Get detailed type info for the completion
+        const typeInfo = await commands.executeCommand({
+          command: 'jsAutocomplete.getTypeInfo',
+          arguments: [item.label, scope.length > 0 ? scope : undefined]
+        });
+        if (typeInfo) {
+          item.documentation = {
+            value: formatDetailedDocumentation(item.label, typeInfo),
+            isTrusted: true
+          };
+        }
+      } catch (error) {
+        console.error('Type info resolution error:', error);
+      }
+      return item;
+    }
+  });
+  // Register completion provider for TypeScript
+  monaco.languages.registerCompletionItemProvider('typescript', {
+    triggerCharacters: ['.', ' '],
+    provideCompletionItems: async (model, position) => {
+      try {
+        const text = model.getValue();
+        const offset = model.getOffsetAt(position);
+        // Call the autocomplete extension command
+        const result = await commands.executeCommand({
+          command: 'jsAutocomplete.getCompletions',
+          arguments: [text, offset, scope.length > 0 ? scope : undefined]
+        });
+        if (!result || !result.completions) {
+          return {
+            suggestions: []
+          };
+        }
+        // Convert to Monaco completion items
+        const suggestions = result.completions.map(completion => ({
+          label: completion.name,
+          kind: determineCompletionKind(completion.type, monaco),
+          documentation: formatDocumentation(completion),
+          insertText: completion.name,
+          detail: completion.type || 'any',
+          sortText: getSortText(completion)
+        }));
+        return {
+          suggestions,
+          incomplete: result.isIncomplete || false
+        };
+      } catch (error) {
+        console.error('TypeScript autocomplete error:', error);
+        return {
+          suggestions: []
+        };
+      }
+    }
+  });
+  // Register hover provider for type information
+  if (enableHoverInfo) {
+    monaco.languages.registerHoverProvider('javascript', {
+      provideHover: async (model, position) => {
+        try {
+          const word = model.getWordAtPosition(position);
+          if (!word) {
+            return null;
+          }
+          // Get type info via extension command
+          const typeInfo = await commands.executeCommand({
+            command: 'jsAutocomplete.getTypeInfo',
+            arguments: [word.word, scope.length > 0 ? scope : undefined]
+          });
+          if (!typeInfo) {
+            return null;
+          }
+          return {
+            range: new monaco.Range(position.lineNumber, word.startColumn, position.lineNumber, word.endColumn),
+            contents: [{
+              value: `**${word.word}**: \`${typeInfo.type || 'any'}\``
+            }, {
+              value: typeInfo.doc || 'No documentation available'
+            }]
+          };
+        } catch (error) {
+          console.error('Hover provider error:', error);
+          return null;
+        }
+      }
+    });
+    monaco.languages.registerHoverProvider('typescript', {
+      provideHover: async (model, position) => {
+        try {
+          const word = model.getWordAtPosition(position);
+          if (!word) {
+            return null;
+          }
+          const typeInfo = await commands.executeCommand({
+            command: 'jsAutocomplete.getTypeInfo',
+            arguments: [word.word, scope.length > 0 ? scope : undefined]
+          });
+          if (!typeInfo) {
+            return null;
+          }
+          return {
+            range: new monaco.Range(position.lineNumber, word.startColumn, position.lineNumber, word.endColumn),
+            contents: [{
+              value: `**${word.word}**: \`${typeInfo.type || 'any'}\``
+            }, {
+              value: typeInfo.doc || 'No documentation available'
+            }]
+          };
+        } catch (error) {
+          console.error('TypeScript hover provider error:', error);
+          return null;
+        }
+      }
+    });
+  }
+  console.log('Monaco autocomplete integration setup complete');
+}
+/**
+ * Setup autocomplete for a specific Inngest step
+ * Provides step-specific context and completions
+ */
+async function setupStepAutocomplete(monaco, step, code, commandService) {
+  const context = getStepCompletionContext(step, code);
+  await setupMonacoAutocomplete(monaco, {
+    enableInngestContext: true,
+    customScope: [...context.scope, ...context.variables],
+    enableHoverInfo: true,
+    commandService
+  }, commandService);
+  // Add step-specific type definitions
+  const typeDefinitions = getStepTypeDefinitions();
+  monaco.languages.typescript.javascriptDefaults.addExtraLib(typeDefinitions, 'file:///inngest-step-types.d.ts');
+}
+/**
+ * Install a library for autocomplete
+ */
+async function installLibraryForAutocomplete(commandService, url, accessors) {
+  try {
+    await commandService.executeCommand({
+      command: 'jsAutocomplete.installLibrary',
+      arguments: [url, accessors]
+    });
+    console.log(`Library installed: ${accessors.join(', ')}`);
+    return true;
+  } catch (error) {
+    console.error('Failed to install library:', error);
+    return false;
+  }
+}
+/**
+ * Update autocomplete configuration
+ */
+async function updateAutocompleteConfig(commandService, config) {
+  try {
+    await commandService.executeCommand({
+      command: 'jsAutocomplete.updateConfig',
+      arguments: [config]
+    });
+    console.log('Autocomplete config updated');
+    return true;
+  } catch (error) {
+    console.error('Failed to update autocomplete config:', error);
+    return false;
+  }
+}
+/**
+ * Get available type definitions
+ */
+async function getAvailableDefinitions(commandService) {
+  try {
+    const definitions = await commandService.executeCommand({
+      command: 'jsAutocomplete.getAvailableDefinitions',
+      arguments: []
+    });
+    return definitions || [];
+  } catch (error) {
+    console.error('Failed to get available definitions:', error);
+    return [];
+  }
+}
+// Helper functions
+function determineCompletionKind(type, monaco) {
+  if (!type) {
+    return monaco.languages.CompletionItemKind.Variable;
+  }
+  if (type.includes('fn(') || type.includes('=>')) {
+    return monaco.languages.CompletionItemKind.Function;
+  }
+  if (type.startsWith('class ') || type.includes('{}')) {
+    return monaco.languages.CompletionItemKind.Class;
+  }
+  if (type.includes('[]')) {
+    return monaco.languages.CompletionItemKind.Field;
+  }
+  if (type === 'number' || type === 'string' || type === 'boolean') {
+    return monaco.languages.CompletionItemKind.Keyword;
+  }
+  return monaco.languages.CompletionItemKind.Variable;
+}
+function formatDocumentation(completion) {
+  const parts = [];
+  if (completion.type) {
+    parts.push(`\`${completion.type}\``);
+  }
+  if (completion.doc) {
+    parts.push(completion.doc);
+  }
+  if (completion.url) {
+    parts.push(`[Documentation](${completion.url})`);
+  }
+  return parts.join('\n\n') || completion.name;
+}
+function formatDetailedDocumentation(name, typeInfo) {
+  const parts = [];
+  parts.push(`## ${name}`);
+  parts.push('');
+  if (typeInfo.type) {
+    parts.push('```typescript');
+    parts.push(typeInfo.type);
+    parts.push('```');
+    parts.push('');
+  }
+  if (typeInfo.doc) {
+    parts.push(typeInfo.doc);
+    parts.push('');
+  }
+  if (typeInfo.url) {
+    parts.push(`[View Documentation](${typeInfo.url})`);
+  }
+  return parts.join('\n');
+}
+function getSortText(completion) {
+  // Prioritize functions and commonly used types
+  if (completion.type?.includes('fn(') || completion.type?.includes('=>')) {
+    return `0_${completion.name}`;
+  }
+  if (completion.type?.startsWith('class ')) {
+    return `1_${completion.name}`;
+  }
+  return `2_${completion.name}`;
+}export{getAvailableDefinitions,installLibraryForAutocomplete,setupMonacoAutocomplete,setupStepAutocomplete,updateAutocompleteConfig};//# sourceMappingURL=monacoAutocompleteIntegration.js.map

package/lib/inngest/monacoAutocompleteIntegration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"monacoAutocompleteIntegration.js","sources":["../../src/inngest/monacoAutocompleteIntegration.ts"],"sourcesContent":[null],"names":[],"mappings":"iFAAA;;;;;AAKG;AAKH;;;;AAII;;;AAGA,eAAA,uBAAA,CAAA,MAAA,EAAA,OAAuD,GAAA,EAAA,EAAA,cAAA,EAAA;QACvD;AACH,IAAA,oBAAA,GAAA,IAAA;AAED,IAAA,WAAA,GAAA,EAAA;;;;;;AAMG,IAAA;AACH,EAAA;AA8OA;;;AAGG,IAAA,KAAA,CAAA,IAAA,CAAA,MAAA,EAAA,OAAA,EAAA,KAAA,EAAA,OAAA,EAAA,WAAA,EAAA,cAAA,CAAA;AACH,EAAA;AAmBA;;AAEG,IAAA,MAAA,EAAA,MAAA,CAAA,SAAA,CAAA,UAAA,CAAA,YAAA,CAAA,MAAA;AACH,IAAA,oBAAsB;AAkBtB,IAAA,gBAAA,EAAA,MAAA,CAAA,SAAA,CAAA,UAAA,CAAA,oBAAA,CAAA,MAAA;;AAEG,IAAA,MAAA,EAAA,IAAA;AACH,IAAA,eAAA,EAAA;IAGQ,OAAA,EAAA,IAAA;IACA,OAAA,EAAA,KAAA;IACA,oBAAA,EAAsB,KAAG;AACzB,IAAA,kBAAkB,EAAE;AACvB,GAAA;AAeL;;AAEG,EAAA,MAAA,CAAA,SAAA,CAAA,UAAA,CAAA,kBAAA,CAAA,kBAAA,CAAA,eAAA,CAAA;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/inngest/stepGenerator.d.ts

@@ -0,0 +1,67 @@
+import type { InngestStep, ExtractedFunction } from './interfaces/types';
+export type { ExtractedFunction } from './interfaces/types';
+/**
+ * Step function generation utilities for unified code generation
+ * Used by both browser editor and server execution
+ *
+ * Integrates with js-autocomplete-extension for intelligent code completion
+ */
+/**
+ * Get scope context for code completion in step functions
+ * Returns available variables and their types for autocomplete
+ */
+export declare function getStepCompletionScope(): string[];
+/**
+ * Get type definitions for step function context
+ * Used by Monaco editor for enhanced IntelliSense
+ */
+export declare function getStepTypeDefinitions(): string;
+/**
+ * Get autocomplete suggestions for a specific step type
+ * Returns context-specific completions based on step type
+ */
+export declare function getStepTypeCompletions(stepType: string): Array<{
+    name: string;
+    snippet: string;
+    doc: string;
+}>;
+/**
+ * Extract variable names from step code for completion context
+ * Returns all declared variables in the step function
+ */
+export declare function extractVariablesFromCode(code: string): string[];
+/**
+ * Get completion context for a step at a specific position
+ * Used by Monaco editor to provide context-aware completions
+ */
+export interface CompletionContext {
+    scope: string[];
+    typeDefinitions: string;
+    snippets: Array<{
+        name: string;
+        snippet: string;
+        doc: string;
+    }>;
+    variables: string[];
+}
+export declare function getStepCompletionContext(step: InngestStep, code: string): CompletionContext;
+export declare function cleanStepCode(code: string): string;
+export declare function extractStepVarName(code: string): string | null;
+export declare function generateDefaultStepFunction(stepVar: string, stepType: string): string;
+export declare function generateStepFunction(step: InngestStep | ExtractedFunction, index: number): {
+    code: string;
+    varName: string;
+};
+export declare function extractFunctionBody(code: string): string | null;
+export declare function transformStepForExecution(stepFunction: {
+    code: string;
+    varName: string;
+}, stepType: string, stepLabel: string): string;
+export declare function generateInngestFunctionFromSteps(stepFunctions: Array<{
+    code: string;
+    varName: string;
+    type?: string;
+    label?: string;
+}>): string;
+export declare function generateFromExtractedFunctions(extractedFunctions: ExtractedFunction[]): string;
+//# sourceMappingURL=stepGenerator.d.ts.map

package/lib/inngest/stepGenerator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stepGenerator.d.ts","sourceRoot":"","sources":["../../src/inngest/stepGenerator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAGzE,YAAY,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAE5D;;;;;GAKG;AAEH;;;GAGG;AACH,wBAAgB,sBAAsB,IAAI,MAAM,EAAE,CAejD;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,IAAI,MAAM,CA+C/C;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,GAAG,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC,CAsD9G;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAmB/D;AAED;;;GAGG;AACH,MAAM,WAAW,iBAAiB;IAC9B,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,eAAe,EAAE,MAAM,CAAC;IACxB,QAAQ,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAChE,SAAS,EAAE,MAAM,EAAE,CAAC;CACvB;AAED,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,GAAG,iBAAiB,CAS3F;AAGD,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAElD;AAGD,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAG9D;AAGD,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CA4FrF;AAGD,wBAAgB,oBAAoB,CAChC,IAAI,EAAE,WAAW,GAAG,iBAAiB,EACrC,KAAK,EAAE,MAAM,GACd;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAYnC;AAGD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CA0E/D;AAED,wBAAgB,yBAAyB,CACrC,YAAY,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,EAC/C,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,GAClB,MAAM,CAsER;AAGD,wBAAgB,gCAAgC,CAC5C,aAAa,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,GACvF,MAAM,CAgCR;AAGD,wBAAgB,8BAA8B,CAAC,kBAAkB,EAAE,iBAAiB,EAAE,GAAG,MAAM,CA6B9F"}

package/lib/inngest/stepGenerator.js

@@ -0,0 +1,243 @@
+/**
+ * Step function generation utilities for unified code generation
+ * Used by both browser editor and server execution
+ *
+ * Integrates with js-autocomplete-extension for intelligent code completion
+ */
+/**
+ * Get scope context for code completion in step functions
+ * Returns available variables and their types for autocomplete
+ */
+function getStepCompletionScope() {
+  return ['step', 'event', 'run', 'sleep', 'sendEvent', 'waitForEvent', 'Promise', 'console', 'Date', 'JSON', 'Array', 'Object'];
+}
+/**
+ * Get type definitions for step function context
+ * Used by Monaco editor for enhanced IntelliSense
+ */
+function getStepTypeDefinitions() {
+  return `
+// Inngest Step API
+declare const step: {
+    run<T>(id: string, fn: (event: any, step: any) => Promise<T> | T): Promise<T>;
+    sendEvent(id: string, input: { name: string; data?: any }): Promise<void>;
+    waitForEvent<T = any>(id: string, opts: { event: string; timeout?: string | number }): Promise<T>;
+    sleep(id: string, ms: string | number): Promise<void>;
+};
+
+// Event context
+declare const event: {
+    data: any;
+    id: string;
+    name: string;
+    ts: number;
+    user?: any;
+};
+
+// Common utilities available in step functions
+declare const console: {
+    log(...args: any[]): void;
+    error(...args: any[]): void;
+    warn(...args: any[]): void;
+    info(...args: any[]): void;
+};
+
+// Promise and async utilities
+declare class Promise<T> {
+    then<TResult>(onfulfilled?: (value: T) => TResult | Promise<TResult>): Promise<TResult>;
+    catch<TResult>(onrejected?: (reason: any) => TResult | Promise<TResult>): Promise<TResult>;
+    finally(onfinally?: () => void): Promise<T>;
+    static all<T>(promises: Promise<T>[]): Promise<T[]>;
+    static race<T>(promises: Promise<T>[]): Promise<T>;
+    static resolve<T>(value: T): Promise<T>;
+    static reject(reason?: any): Promise<never>;
+}
+
+// Date utilities
+declare class Date {
+    constructor();
+    constructor(value: number | string);
+    toISOString(): string;
+    getTime(): number;
+    static now(): number;
+}
+`;
+}
+/**
+ * Get autocomplete suggestions for a specific step type
+ * Returns context-specific completions based on step type
+ */
+function getStepTypeCompletions(stepType) {
+  const completions = {
+    sleep: [{
+      name: 'step.sleep',
+      snippet: "await step.sleep('${1:step-id}', '${2:5s}');",
+      doc: 'Sleep for a specified duration. Accepts time strings like "5s", "1m", "1h"'
+    }],
+    sendEvent: [{
+      name: 'step.sendEvent',
+      snippet: `await step.sendEvent('\${1:step-id}', {
+  name: '\${2:event.name}',
+  data: {
+    \${3:key}: \${4:value}
+  }
+});`,
+      doc: 'Send an event to trigger other workflows'
+    }],
+    waitForEvent: [{
+      name: 'step.waitForEvent',
+      snippet: `const \${1:result} = await step.waitForEvent('\${2:step-id}', {
+  event: '\${3:event.name}',
+  timeout: '\${4:60s}'
+});`,
+      doc: 'Wait for a specific event before continuing'
+    }],
+    run: [{
+      name: 'step.run',
+      snippet: `const \${1:result} = await step.run('\${2:step-id}', async () => {
+  \${3:// Your logic here}
+  return { success: true };
+});`,
+      doc: 'Run a unit of work with automatic retries and error handling'
+    }],
+    parallel: [{
+      name: 'Promise.all',
+      snippet: `const results = await Promise.all([
+  \${1:step.run('step-1', async () => { return 1; })},
+  \${2:step.run('step-2', async () => { return 2; })}
+]);`,
+      doc: 'Execute multiple steps in parallel'
+    }]
+  };
+  return completions[stepType] || completions.run;
+}
+/**
+ * Extract variable names from step code for completion context
+ * Returns all declared variables in the step function
+ */
+function extractVariablesFromCode(code) {
+  const variables = [];
+  // Match const/let/var declarations
+  const declRegex = /(?:const|let|var)\s+(\w+)/g;
+  let match;
+  while ((match = declRegex.exec(code)) !== null) {
+    variables.push(match[1]);
+  }
+  // Match function parameters
+  const paramRegex = /(?:async\s+)?\(([^)]*)\)\s*=>/g;
+  while ((match = paramRegex.exec(code)) !== null) {
+    const params = match[1].split(',').map(p => p.trim().split(/\s+/)[0]);
+    variables.push(...params.filter(p => p && p !== ''));
+  }
+  return [...new Set(variables)]; // Remove duplicates
+}
+function getStepCompletionContext(step, code) {
+  const stepType = step.type || 'run';
+  return {
+    scope: getStepCompletionScope(),
+    typeDefinitions: getStepTypeDefinitions(),
+    snippets: getStepTypeCompletions(stepType),
+    variables: extractVariablesFromCode(code)
+  };
+}
+// Pass through code without any cleaning/validation
+function cleanStepCode(code) {
+  return code;
+}
+// Extract step variable name from code
+function extractStepVarName(code) {
+  const match = code.match(/const\s+(\w+)\s*=/);
+  return match ? match[1] : null;
+}
+// Extract function body from step function code
+function extractFunctionBody(code) {
+  // Find the opening brace after the arrow or function keyword
+  const arrowIndex = code.indexOf('=>');
+  const functionIndex = code.indexOf('function');
+  let startIndex = -1;
+  if (arrowIndex !== -1) {
+    // Find opening brace after =>
+    const openBraceIndex = code.indexOf('{', arrowIndex);
+    if (openBraceIndex !== -1) {
+      startIndex = openBraceIndex + 1;
+    }
+  } else if (functionIndex !== -1) {
+    // Find opening brace after function declaration
+    const openBraceIndex = code.indexOf('{', functionIndex);
+    if (openBraceIndex !== -1) {
+      startIndex = openBraceIndex + 1;
+    }
+  }
+  if (startIndex === -1) {
+    // FALLBACK: If we can't find function wrapper, return the whole code
+    console.warn('Could not extract function body, returning full code');
+    return code;
+  }
+  // Find the matching closing brace by counting braces
+  let braceCount = 1;
+  let endIndex = startIndex;
+  let inString = false;
+  let stringChar = '';
+  let inTemplate = false;
+  while (endIndex < code.length && braceCount > 0) {
+    const char = code[endIndex];
+    const prevChar = endIndex > 0 ? code[endIndex - 1] : '';
+    // Handle string literals
+    if ((char === '"' || char === "'") && prevChar !== '\\') {
+      if (!inString) {
+        inString = true;
+        stringChar = char;
+      } else if (char === stringChar) {
+        inString = false;
+      }
+    }
+    // Handle template literals
+    if (char === '`' && prevChar !== '\\') {
+      inTemplate = !inTemplate;
+    }
+    // Only count braces outside of strings
+    if (!inString && !inTemplate) {
+      if (char === '{') {
+        braceCount++;
+      } else if (char === '}') {
+        braceCount--;
+      }
+    }
+    if (braceCount > 0) {
+      endIndex++;
+    }
+  }
+  if (braceCount === 0) {
+    return code.substring(startIndex, endIndex).trim();
+  }
+  // FALLBACK: Return full code if brace matching fails
+  console.warn('Brace matching failed, returning full code');
+  return code;
+}
+// Convert ExtractedFunction array to step functions and generate Inngest function
+function generateFromExtractedFunctions(extractedFunctions) {
+  if (extractedFunctions.length === 0) {
+    return 'return { success: false, error: "No functions to execute" };';
+  }
+  // For functions that are complete workflow steps (like step_416),
+  // just return the code body directly without extraction
+  const func = extractedFunctions[0];
+  // Check if this is a complete function (has async function signature)
+  if (func.code && func.code.includes('async function')) {
+    // Extract just the body, preserving all helper functions and logic
+    const bodyMatch = func.code.match(/async function[^{]*\{([\s\S]*)\}[\s]*$/);
+    if (bodyMatch) {
+      return bodyMatch[1].trim();
+    }
+  }
+  // Check if code has arrow function format: const x = async (event, step) => { ... }
+  if (func.code && func.code.includes('async') && func.code.includes('=>')) {
+    const arrowBodyMatch = func.code.match(/=>\s*\{([\s\S]*)\}[\s]*;?[\s]*$/);
+    if (arrowBodyMatch) {
+      return arrowBodyMatch[1].trim();
+    }
+  }
+  // Fallback: return the code as-is if we can't parse it
+  console.warn('Could not parse function format, returning code as-is');
+  return func.code || 'return { success: false, error: "No code available" };';
+}export{cleanStepCode,extractFunctionBody,extractStepVarName,extractVariablesFromCode,generateFromExtractedFunctions,getStepCompletionContext,getStepCompletionScope,getStepTypeCompletions,getStepTypeDefinitions};//# sourceMappingURL=stepGenerator.js.map

package/lib/inngest/stepGenerator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stepGenerator.js","sources":["../../src/inngest/stepGenerator.ts"],"sourcesContent":[null],"names":[],"mappings":"AAAA;AAGA;AAEA;;;;;AAKG;AAEH;;;AAGG,EAAA,OAAA,CAAA,MAAA,EAAA,OAAA,EAAA,KAAA,EAAA,OAAA,EAAA,WAAA,EAAA,cAAA,EAAA,SAAA,EAAA,SAAA,EAAA,MAAA,EAAA,MAAA,EAAA,OAAA,EAAA,QAAA,CAAA;AACH;AAiBA;;;AAGG;AACH,SAAA,sBAAgB,GAAA;AAiDhB,EAAA,OAAA;;;AAGG;AACH;;;;;AAwDA;;;AAGG;AACH;AAqBA;;;;AAIA;;;;;;;;;AAKC;AAED;AAYA;AAKA;AAMA;AA+FA;;;;;AA8FA;;;;AA6EA;;;;;;AAqCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/utils/json.d.ts

@@ -0,0 +1,3 @@
+export declare function flatten(obj: Record<string, unknown>, parentKey?: string, res?: Record<string, unknown>): Record<string, unknown>;
+export declare function unflatten(obj: Record<string, unknown>): {};
+//# sourceMappingURL=json.d.ts.map

package/lib/utils/json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../../src/utils/json.ts"],"names":[],"mappings":"AAAA,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,SAAS,SAAK,EAAE,GAAG,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,2BAoBtG;AAED,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,MA2BrD"}