@elyx-code/project-logic-tree 0.0.7222 → 0.0.7224

package/dist/editor/extensions/module/command-step-resolver.d.ts

@@ -0,0 +1,9 @@
+import { IComposableCommand, ICommandStepResolution, ICommandPart } from './extensions';
+
+export declare function getSubcommandsList(cmd: IComposableCommand): IComposableCommand[];
+export declare function getSubcommandsMap(cmd: IComposableCommand): Record<string, IComposableCommand>;
+/**
+ * Dynamically resolves the active step, placeholder, ghost hint, and completion state
+ * for a composable command based on the sequence of confirmed parts and active input.
+ */
+export declare function resolveCommandStep(command: IComposableCommand | null | undefined, confirmedParts: ICommandPart[], activeSegmentText: string, _ctx?: any): ICommandStepResolution;

package/dist/editor/extensions/module/extensions.d.ts

@@ -73,16 +73,180 @@ export interface ICommandSubcommandOption {
     description: string;
     category: string;
 }
+export declare enum CommandExecutionType {
+    ClientProcess = "client-process",
+    AgentProcess = "agent-process"
+}
 export interface ICommandDefinition {
     command: string;
     label: string;
     description?: string;
     category: string;
-    executionType?: 'fe-action' | 'backend-process' | 'ai-prompt';
-    hasRichEditor?: boolean;
+    executionType: CommandExecutionType | 'client-process' | 'agent-process';
     subcommands?: ICommandSubcommandOption[];
     args?: ICommandArgDef[];
 }
+export declare enum NamedColor {
+    MainGrey = "main-grey",
+    LightGrey = "light-grey",
+    DarkGrey = "dark-grey",
+    LighterGrey = "lighter-grey",
+    BackgroundGrey = "background-grey",
+    MainPrimary = "main-primary",
+    SupportPrimary = "support-primary",
+    TextPrimary = "text-primary",
+    ContrastPrimary = "contrast-primary",
+    LightContrastPrimary = "light-contrast-primary",
+    BackgroundPrimary = "background-primary",
+    MainError = "main-error",
+    MainDarkError = "main-dark-error",
+    SupportError = "support-error",
+    TextError = "text-error",
+    ContrastError = "contrast-error",
+    BackgroundError = "background-error",
+    MainSuccess = "main-success",
+    MainDarkSuccess = "main-dark-success",
+    SupportSuccess = "support-success",
+    TextSuccess = "text-success",
+    ContrastSuccess = "contrast-success",
+    BackgroundSuccess = "background-success",
+    MainWarning = "main-warning",
+    SupportWarning = "support-warning",
+    TextWarning = "text-warning",
+    ContrastWarning = "contrast-warning",
+    BackgroundWarning = "background-warning",
+    BackgroundDefinitionEntity = "background--definition-entity",
+    BackgroundSupportDefinitionEntity = "background-support--definition-entity",
+    BackgroundSuggestionDefinitionEntity = "background-suggestion--definition-entity",
+    BackgroundSupportSuggestionDefinitionEntity = "background-support-suggestion--definition-entity",
+    BackgroundDisabledDefinitionEntity = "background-disabled--definition-entity",
+    IconDefinitionEntity = "icon--definition-entity",
+    TextDefinitionEntity = "text--definition-entity",
+    BackgroundProperty = "background--property",
+    BackgroundSupportProperty = "background-support--property",
+    IconProperty = "icon--property",
+    TextProperty = "text--property",
+    BackgroundFunctionCall = "background--function-call",
+    BackgroundOperation = "background--operation",
+    BackgroundSupportFunctionCall = "background-support--function-call",
+    BackgroundSupportOperation = "background-support--operation",
+    BackgroundSuggestionFunctionCall = "background-suggestion--function-call",
+    BackgroundSuggestionOperation = "background-suggestion--operation",
+    BackgroundSupportSuggestionFunctionCall = "background-support-suggestion--function-call",
+    BackgroundSupportSuggestionOperation = "background-support-suggestion--operation",
+    BackgroundDisabledFunctionCall = "background-disabled--function-call",
+    BackgroundDisabledOperation = "background-disabled--operation",
+    IconFunctionCall = "icon--function-call",
+    IconOperation = "icon--operation",
+    TextFunctionCall = "text--function-call",
+    TextOperation = "text--operation",
+    BackgroundInternalCall = "background--internal-call",
+    BackgroundSupportInternalCall = "background-support--internal-call",
+    BackgroundSuggestionInternalCall = "background-suggestion--internal-call",
+    BackgroundSupportSuggestionInternalCall = "background-support-suggestion--internal-call",
+    BackgroundDisabledInternalCall = "background-disabled--internal-call",
+    IconInternalCall = "icon--internal-call",
+    TextInternalCall = "text--internal-call",
+    BackgroundGlobalEvent = "background--global-event",
+    BackgroundFunctionDeclaration = "background--function-declaration",
+    BackgroundSupportGlobalEvent = "background-support--global-event",
+    BackgroundSupportFunctionDeclaration = "background-support--function-declaration",
+    BackgroundSuggestionFunctionDeclaration = "background-suggestion--function-declaration",
+    BackgroundSuggestionGlobalEvent = "background-suggestion--global-event",
+    BackgroundSupportSuggestionFunctionDeclaration = "background-support-suggestion--function-declaration",
+    BackgroundSupportSuggestionGlobalEvent = "background-support-suggestion--global-event",
+    BackgroundDisabledGlobalEvent = "background-disabled--global-event",
+    BackgroundDisabledFunctionDeclaration = "background-disabled--function-declaration",
+    IconGlobalEvent = "icon--global-event",
+    IconFunctionDeclaration = "icon--function-declaration",
+    TextGlobalEvent = "text--global-event",
+    TextFunctionDeclaration = "text--function-declaration",
+    BackgroundProject = "background--project",
+    BackgroundSupportProject = "background-support--project",
+    BackgroundSuggestionProject = "background-suggestion--project",
+    BackgroundSupportSuggestionProject = "background-support-suggestion--project",
+    BackgroundDisabledProject = "background-disabled--project",
+    IconProject = "icon--project",
+    TextProject = "text--project",
+    BackgroundCondition = "background--condition",
+    BackgroundSupportCondition = "background-support--condition",
+    BackgroundSuggestionCondition = "background-suggestion--condition",
+    BackgroundSupportSuggestionCondition = "background-support-suggestion--condition",
+    BackgroundDisabledCondition = "background-disabled--condition",
+    IconCondition = "icon--condition",
+    TextCondition = "text--condition",
+    BackgroundReturnStatement = "background--return-statement",
+    BackgroundLightReturnStatement = "background-light--return-statement",
+    BackgroundContinueStatement = "background--continue-statement",
+    BackgroundLightContinueStatement = "background-light--continue-statement",
+    BackgroundBreakStatement = "background--break-statement",
+    BackgroundLightBreakStatement = "background-light--break-statement",
+    BackgroundSupportReturnStatement = "background-support--return-statement",
+    BackgroundSupportContinueStatement = "background-support--continue-statement",
+    BackgroundSupportBreakStatement = "background-support--break-statement",
+    BackgroundSuggestionReturnStatement = "background-suggestion--return-statement",
+    BackgroundSuggestionContinueStatement = "background-suggestion--continue-statement",
+    BackgroundSuggestionBreakStatement = "background-suggestion--break-statement",
+    BackgroundSupportSuggestionReturnStatement = "background-support-suggestion--return-statement",
+    BackgroundSupportSuggestionContinueStatement = "background-support-suggestion--continue-statement",
+    BackgroundSupportSuggestionBreakStatement = "background-support-suggestion--break-statement",
+    BackgroundDisabledReturnStatement = "background-disabled--return-statement",
+    BackgroundDisabledContinueStatement = "background-disabled--continue-statement",
+    BackgroundDisabledBreakStatement = "background-disabled--break-statement",
+    IconReturnStatement = "icon--return-statement",
+    IconContinueStatement = "icon--continue-statement",
+    IconBreakStatement = "icon--break-statement",
+    TextReturnStatement = "text--return-statement",
+    TextContinueStatement = "text--continue-statement",
+    TextBreakStatement = "text--break-statement",
+    BackgroundVariableDeclaration = "background--variable-declaration",
+    BackgroundVariableInstance = "background--variable-instance",
+    BackgroundSupportVariableDeclaration = "background-support--variable-declaration",
+    BackgroundSupportVariableInstance = "background-support--variable-instance",
+    BackgroundSuggestionVariableDeclaration = "background-suggestion--variable-declaration",
+    BackgroundSuggestionVariableInstance = "background-suggestion--variable-instance",
+    BackgroundSupportSuggestionVariableDeclaration = "background-support-suggestion--variable-declaration",
+    BackgroundSupportSuggestionVariableInstance = "background-support-suggestion--variable-instance",
+    BackgroundDisabledVariableDeclaration = "background-disabled--variable-declaration",
+    BackgroundDisabledVariableInstance = "background-disabled--variable-instance",
+    IconVariableDeclaration = "icon--variable-declaration",
+    IconVariableInstance = "icon--variable-instance",
+    TextVariableDeclaration = "text--variable-declaration",
+    TextVariableInstance = "text--variable-instance",
+    BackgroundLoop = "background--loop",
+    BackgroundSupportLoop = "background-support--loop",
+    BackgroundSuggestionLoop = "background-suggestion--loop",
+    BackgroundSupportSuggestionLoop = "background-support-suggestion--loop",
+    BackgroundDisabledLoop = "background-disabled--loop",
+    IconLoop = "icon--loop",
+    TextLoop = "text--loop",
+    BackgroundSearch = "background--search",
+    BackgroundSupportSearch = "background-support--search",
+    BackgroundSuggestionSearch = "background-suggestion--search",
+    BackgroundSupportSuggestionSearch = "background-support-suggestion--search",
+    BackgroundDisabledSearch = "background-disabled--search",
+    IconSearch = "icon--search",
+    TextSearch = "text--search",
+    StringValue = "string--value",
+    NumberValue = "number--value",
+    BooleanValue = "boolean--value",
+    ListValue = "list--value",
+    ObjectValue = "object--value"
+}
+export interface ICommandPart {
+    index: number;
+    type: 'command' | 'subcommand' | 'option' | 'argument' | 'text' | 'node';
+    label: string;
+    sublabel?: string;
+    value: string;
+    color?: string;
+    namedColor?: NamedColor | string;
+    icon?: string;
+    metadata?: {
+        entity?: any;
+        [key: string]: unknown;
+    };
+}
 export interface ICommandExecutionContext {
     project?: any;
     conversationId: string;
@@ -91,19 +255,99 @@ export interface ICommandExecutionContext {
     option?: string;
     args: Record<string, any>;
     rawInput: string;
+    parts?: ICommandPart[];
+}
+export interface ICommandAutocompleteContext {
+    project?: any;
+    conversationId?: string;
+    command?: string;
+    subcommand?: string;
+    option?: string;
+    args?: Record<string, any>;
+    rawInput?: string;
+    parts?: ICommandPart[];
+    [key: string]: unknown;
+}
+export interface IBeforeSubmitResult {
+    canProceed: boolean;
+    notification?: {
+        text: string;
+        color?: 'success' | 'error' | 'warning' | 'info';
+    };
+    widgetType?: string;
+    widgetPayload?: any;
+    message?: string;
 }
 export interface ICommandExecutionResult {
     success: boolean;
     message?: string;
-    widgetType?: string;
-    widgetPayload?: any;
-    createdEntityId?: string;
-    createdEntityName?: string;
+    payload?: {
+        command?: string;
+        parts?: ICommandPart[];
+        changeSetId?: string;
+        publicationId?: string;
+        createdEntityId?: string;
+        createdEntityName?: string;
+        icons?: Record<string, string>;
+        [key: string]: unknown;
+    };
+    metadata?: Record<string, unknown>;
 }
 export type CommandStage = 'normal' | 'command' | 'subcommand' | 'option' | 'args';
+export type CommandStepType = 'subcommand' | 'option' | 'argument' | 'custom';
+export interface ICommandOptionItem<TMetadata = any> {
+    id: string;
+    label: string;
+    sublabel?: string;
+    categoryTag?: string;
+    icon?: string;
+    color?: string;
+    namedColor?: NamedColor | string;
+    colorType?: string;
+    rendererId?: string;
+    metadata?: TMetadata;
+    rawEntity?: any;
+}
+export interface ICommandStep<TContext = any> {
+    id: string;
+    type: CommandStepType;
+    label: string;
+    placeholder?: string;
+    ghostHint?: string;
+    required?: boolean;
+    allowFreeText?: boolean;
+    getOptions?: (query: string, ctx: TContext) => Promise<ICommandOptionItem[]>;
+    resolvePart: (valueOrOption: any, ctx: TContext, partIndex: number) => ICommandPart;
+    isStepSatisfied?: (value: string | ICommandPart, ctx: TContext) => boolean;
+}
+export interface IComposableCommand<TContext = any> {
+    name: string;
+    label?: string;
+    description?: string;
+    category?: string;
+    icon?: string;
+    namedColor?: NamedColor | string;
+    subcommands?: Record<string, IComposableCommand<TContext>> | IComposableCommand<TContext>[];
+    steps?: ICommandStep<TContext>[];
+    beforeSubmit?: (ctx: ICommandExecutionContext) => Promise<IBeforeSubmitResult>;
+    execute?: (ctx: ICommandExecutionContext) => Promise<ICommandExecutionResult>;
+    getOptions?: (stage: CommandStage, query: string, ctx: ICommandAutocompleteContext) => Promise<any[]>;
+}
+export interface ICommandStepResolution<TContext = any> {
+    activeCommand: IComposableCommand<TContext> | ICommandExtension | null;
+    activeSubcommand?: IComposableCommand<TContext> | null;
+    currentStep: ICommandStep<TContext> | null;
+    stepIndex: number;
+    isComplete: boolean;
+    placeholder: string;
+    ghostHint?: string;
+    allowFreeText: boolean;
+    stage: CommandStage;
+}
 export interface ICommandExtensionModule extends IExtensionModuleCore {
+    beforeSubmit?: (ctx: ICommandExecutionContext) => Promise<IBeforeSubmitResult>;
     execute: (ctx: ICommandExecutionContext) => Promise<ICommandExecutionResult>;
-    getOptions?: (stage: CommandStage, query: string, ctx: any) => Promise<any[]>;
+    getOptions?: (stage: CommandStage, query: string, ctx: ICommandAutocompleteContext) => Promise<any[]>;
 }
 export interface IExtensionModuleCore {
     /** Called once on editor startup */
@@ -131,17 +375,17 @@ export declare class ExtensionState extends BaseExtensionState implements IExten
 export interface IRegisteredExtension<T = any> extends IExecutionClient {
     extensionsRegistry: ExtensionsRegistry;
     manifest: ExtensionManifest;
-    command?: ICommandDefinition;
+    command?: ICommandDefinition | IComposableCommand;
     module: ExtensionModule<T>;
     state: IExtensionState;
 }
 export interface ICommandExtension extends IRegisteredExtension<ICommandExtensionModule> {
-    command: ICommandDefinition;
+    command: ICommandDefinition | IComposableCommand;
 }
 export declare class BaseRegisteredExtension<T = any> implements IRegisteredExtension<T> {
     readonly extensionsRegistry: ExtensionsRegistry;
     manifest: ExtensionManifest;
-    command?: ICommandDefinition;
+    command?: ICommandDefinition | IComposableCommand;
     module: ExtensionModule<T>;
     state: ExtensionState;
     constructor(extensionsRegistry: ExtensionsRegistry, initialState?: Record<string, any>);

package/dist/editor/extensions/module/index.d.ts

@@ -1,2 +1,3 @@
 export * from './extensions';
 export * from './defaults';
+export * from './command-step-resolver';