@adminide-stack/form-builder-core 5.1.4-alpha.62 → 5.1.4-alpha.66

package/CHANGELOG.md

@@ -3,6 +3,10 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [5.1.4-alpha.66](https://github.com/CDEBase/forms-stack/compare/v5.1.4-alpha.65...v5.1.4-alpha.66) (2025-10-16)
+
+**Note:** Version bump only for package @adminide-stack/form-builder-core
+
 ## [5.1.4-alpha.62](https://github.com/CDEBase/forms-stack/compare/v5.1.4-alpha.61...v5.1.4-alpha.62) (2025-10-11)
 
 **Note:** Version bump only for package @adminide-stack/form-builder-core

package/lib/index.d.ts

@@ -1,4 +1,5 @@
 export * from './inngest/interfaces/types';
 export * from './inngest/generateFunctionCode';
 export { generateFromExtractedFunctions } from './inngest/stepGenerator';
+export * from './inngest/monacoAutocompleteIntegration';
 //# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAC3C,cAAc,gCAAgC,CAAC;AAC/C,OAAO,EAAE,8BAA8B,EAAE,MAAM,yBAAyB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAC3C,cAAc,gCAAgC,CAAC;AAC/C,OAAO,EAAE,8BAA8B,EAAE,MAAM,yBAAyB,CAAC;AACzE,cAAc,yCAAyC,CAAC"}

package/lib/index.js

@@ -1 +1 @@
-export{generateFunctionCode,generateHandlerBody,generateStepFromFunction,generateStepFunctionsFromDB,wrapStepsInInngestFunction}from'./inngest/generateFunctionCode.js';export{cleanStepCode,extractStepVarName,generateFromExtractedFunctions}from'./inngest/stepGenerator.js';//# sourceMappingURL=index.js.map
+export{generateFunctionCode,generateHandlerBody,generateStepFromFunction,generateStepFunctionsFromDB,wrapStepsInInngestFunction}from'./inngest/generateFunctionCode.js';export{cleanStepCode,extractStepVarName,generateFromExtractedFunctions}from'./inngest/stepGenerator.js';export{getAvailableDefinitions,installLibraryForAutocomplete,setupMonacoAutocomplete,setupStepAutocomplete,updateAutocompleteConfig}from'./inngest/monacoAutocompleteIntegration.js';//# sourceMappingURL=index.js.map

package/lib/inngest/monacoAutocompleteIntegration.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Monaco Editor Integration for JavaScript Autocomplete
+ *
+ * Integrates with the js-autocomplete-extension via command execution
+ * to provide intelligent code completions in step function editors.
+ */
+import type { InngestStep } from './interfaces/types';
+export interface MonacoAutocompleteOptions {
+    /** Enable Inngest step functions context */
+    enableInngestContext?: boolean;
+    /** Custom scope variables */
+    customScope?: string[];
+    /** Enable type info on hover */
+    enableHoverInfo?: boolean;
+    /** Command service for executing extension commands */
+    commandService?: any;
+}
+/**
+ * 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
+ */
+export declare function setupMonacoAutocomplete(monaco: any, options?: MonacoAutocompleteOptions, commandService?: any): Promise<void>;
+/**
+ * Setup autocomplete for a specific Inngest step
+ * Provides step-specific context and completions
+ */
+export declare function setupStepAutocomplete(monaco: any, step: InngestStep, code: string, commandService: any): Promise<void>;
+/**
+ * Install a library for autocomplete
+ */
+export declare function installLibraryForAutocomplete(commandService: any, url: string, accessors: string[]): Promise<boolean>;
+/**
+ * Update autocomplete configuration
+ */
+export declare function updateAutocompleteConfig(commandService: any, config: {
+    includeDefaults?: boolean;
+    includeLibraries?: boolean;
+    enableDynamicLibraries?: boolean;
+    customDefinitions?: string[];
+}): Promise<boolean>;
+/**
+ * Get available type definitions
+ */
+export declare function getAvailableDefinitions(commandService: any): Promise<string[]>;
+//# sourceMappingURL=monacoAutocompleteIntegration.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"monacoAutocompleteIntegration.d.ts","sourceRoot":"","sources":["../../src/inngest/monacoAutocompleteIntegration.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEtD,MAAM,WAAW,yBAAyB;IACtC,4CAA4C;IAC5C,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,6BAA6B;IAC7B,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,gCAAgC;IAChC,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,uDAAuD;IACvD,cAAc,CAAC,EAAE,GAAG,CAAC;CACxB;AAED;;;;;;GAMG;AACH,wBAAsB,uBAAuB,CACzC,MAAM,EAAE,GAAG,EACX,OAAO,GAAE,yBAA8B,EACvC,cAAc,CAAC,EAAE,GAAG,iBAyOvB;AAED;;;GAGG;AACH,wBAAsB,qBAAqB,CAAC,MAAM,EAAE,GAAG,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,EAAE,cAAc,EAAE,GAAG,iBAiB5G;AAED;;GAEG;AACH,wBAAsB,6BAA6B,CAC/C,cAAc,EAAE,GAAG,EACnB,GAAG,EAAE,MAAM,EACX,SAAS,EAAE,MAAM,EAAE,GACpB,OAAO,CAAC,OAAO,CAAC,CAYlB;AAED;;GAEG;AACH,wBAAsB,wBAAwB,CAC1C,cAAc,EAAE,GAAG,EACnB,MAAM,EAAE;IACJ,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAC;CAChC,GACF,OAAO,CAAC,OAAO,CAAC,CAYlB;AAED;;GAEG;AACH,wBAAsB,uBAAuB,CAAC,cAAc,EAAE,GAAG,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAWpF"}

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

@@ -3,7 +3,48 @@ 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;

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

@@ -1 +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;;;GAGG;AAGH,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"}
+{"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

@@ -1,7 +1,145 @@
 /**
  * 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;
@@ -102,4 +240,4 @@ function generateFromExtractedFunctions(extractedFunctions) {
   // 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,generateFromExtractedFunctions};//# sourceMappingURL=stepGenerator.js.map
+}export{cleanStepCode,extractFunctionBody,extractStepVarName,extractVariablesFromCode,generateFromExtractedFunctions,getStepCompletionContext,getStepCompletionScope,getStepTypeCompletions,getStepTypeDefinitions};//# sourceMappingURL=stepGenerator.js.map

package/lib/inngest/stepGenerator.js.map

@@ -1 +1 @@
-{"version":3,"file":"stepGenerator.js","sources":["../../src/inngest/stepGenerator.ts"],"sourcesContent":[null],"names":[],"mappings":"AAAA;AAGA;AAEA;;;AAGG,SAAA,aAAA,CAAA,IAAA,EAAA;AAGH,EAAA,OAAA,IAAA;AAKA;AAMA;AA+FA,SAAA,kBAAgB,CAAA,IAAA,EAAA;QAGP,QAAQ,IAAC,CAAA,KAAA,CAAA,mBAAA,CAAA;SAAC,aAAe,CAAA,CAAA,CAAA,GAAA,IAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"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/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@adminide-stack/form-builder-core",
-    "version": "5.1.4-alpha.62",
+    "version": "5.1.4-alpha.66",
     "sideEffects": false,
     "type": "module",
     "main": "lib/index.js",
@@ -24,5 +24,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "fcec3b786ecb2cf883d2ca10d7e97bc7381f341d"
+    "gitHead": "38642244b69e8c665139fb1a3cbc5f4c524f99d5"
 }

package/src/index.ts

@@ -1,3 +1,4 @@
 export * from './inngest/interfaces/types';
 export * from './inngest/generateFunctionCode';
 export { generateFromExtractedFunctions } from './inngest/stepGenerator';
+export * from './inngest/monacoAutocompleteIntegration';