Code Completion

The Concord IntelliJ Plugin provides intelligent, context-aware code completion for every part of your Concord flows. It understands the Concord schema and your project structure to suggest relevant keys, steps, and parameters.

YAML Key Completion

As you type in a .concord.yaml file, the plugin suggests valid keys based on your current location:

• Top-level sections: flows, configuration, triggers, forms, etc.
• Step types: Inside a flow, it suggests call, log, task, checkpoint, if, and others.
• Call input parameters: When using a call step, the plugin suggests input parameter names in the in block defined in the target flow's Documentation Block.
• Call output parameters: When using a call step, the plugin suggests output parameter names in the out field defined in the target flow's Documentation Block.
• Task parameters: When using a task step, the plugin suggests input parameters and their values from built-in task schemas. See Task Parameter Completion below.

Task Name Completion

When writing a task step, the plugin suggests available task names extracted from your project's Maven dependencies:

• The plugin resolves JARs declared in configuration.dependencies and configuration.extraDependencies.
• Task names are extracted from @Named annotations inside the dependency JARs.
• Suggestions are scope-aware — each scope only shows tasks from its own dependencies.

configuration:
  dependencies:
  - "mvn://com.walmartlabs.concord.plugins.basic:smtp-tasks:2.35.0"

flows:
  main:
    - task: sm  # Ctrl+Space suggests: smtp
      in:
        to: "user@example.com"

tip

If you add a new dependency and don't see its tasks in completion, use the floating Refresh toolbar that appears in the editor, or click Refresh in the Concord tool window. See Dependency Change Tracking for details.

Task Parameter Completion

When writing the in block of a task step, the plugin suggests parameter names and values from built-in task schemas:

• Parameter keys: Suggests valid input parameter names for the given task.
• Enum values: For parameters that accept a fixed set of values (e.g. action, method), suggests the allowed options.
• Conditional parameters: Suggestions adapt based on already specified values. For example, after setting action: start, only parameters relevant to the start action are suggested.

flows:
  main:
    - task: concord
      in:
        action: start
        # Ctrl+Space here suggests parameters for the "start" action:
        # repo, org, project, payload, ...

Call Output Parameter Completion

When writing the out field of a call step, the plugin suggests output parameter names from the target flow's Documentation Block. This works for both scalar and array forms of the out field.

The completion popup shows:

• Parameter name — the output variable name
• Type — shown on the right side (e.g. int, string)

Completion popup suggesting output parameter names from the target flow's documentation block.

Expression Variable Completion

Inside ${...} expressions, the plugin suggests variable names that are in scope at the current cursor position. Press CtrlSpace to trigger completion.

Each suggestion displays:

• A variable icon for quick visual identification
• The variable name
• The source label after the name (e.g. built-in, set, flow in), so you know where the variable comes from
• The type on the right side (e.g. string, object, integer) for variables that have schema information — built-in variables, loop variables, and flow input parameters all show their types

The following variable sources are recognized:

• built-in — Concord runtime variables like txId, workDir, initiator, processInfo, etc. These have full type information, including sub-fields for object-type variables.
• argument — Variables declared in configuration.arguments.
• flow in — Input parameters defined in the flow's Documentation Block. The type from the doc block is shown (e.g. string, int, object).
• set — Variables assigned by set steps earlier in the flow.
• step out — Variables captured by out fields of preceding steps.
• loop — Loop iteration variables (item, items, itemIndex) available inside loop steps. These show their types (integer for itemIndex, array for items).
• task result — The implicit result variable available inside the out block of a task step.

Completion is context-aware — it only suggests standalone variable names at the top level, not inside function names. After a dot, the plugin switches to property completion instead.

Variable completion inside an EL expression, showing variable icons, source labels, and types.

Expression Property Completion

When you type a dot after a variable name inside a ${...} expression, the plugin suggests the available properties of that variable. Press CtrlSpace to trigger completion.

Each suggestion displays:

• A property icon for quick visual identification
• The property name
• The type on the right side (e.g. string, integer, object)

Property completion works for any variable whose type is known:

• Built-in objects — variables like initiator, projectInfo, and processInfo have full property schemas. For example, ${initiator.} suggests username, displayName, email, groups, and attributes.
• Set step objects — variables assigned by set steps with nested mappings. For example, after setting config.host and config.port, ${config.} suggests host and port.
• Task result — the result variable inside a task's out block. For example, ${result.} suggests properties defined in the task schema's output section (e.g. ok, body).
• Deep nesting — property completion works at any depth. After ${config.db.}, it suggests the properties of the db sub-object.

Property completion after a dot in an EL expression, showing available sub-fields with types.

note

Property completion does not fire after bracket access (items[0].) or method calls (config.toString().), since the resulting type cannot be statically determined from the YAML structure.

Flow Documentation Completion

When writing structured flow documentation (/** ... */), the plugin helps you define your parameters correctly:

• Types: Suggests valid Concord types like string, int, boolean, object, and their array counterparts (string[], etc.).
• Keywords: Suggests keywords like mandatory, required, and optional after the parameter type.

Quick Documentation in Completion

While the completion list is open, you can preview the documentation for the selected item without accepting it. Press CtrlQ to open a documentation popup next to the completion list.

YAML Key Documentation

Selecting a key like flows, configuration, task, or call in the completion list shows a short description of that key's purpose.

Quick documentation for a YAML key selected in the completion list.

Task Name Documentation

When completing a task name, the documentation popup shows the full task description along with its input and output parameters, types, and descriptions — the same information you would see when hovering over a task name in the editor.

flows:
  main:
    - task: co  # Ctrl+Space, then Ctrl+Q on "concord"

Quick documentation for a task name showing description, input and output parameters.

Task Parameter Documentation

When completing parameters inside a task's in block, the documentation popup shows the type and description of the selected parameter.

Quick documentation for a task parameter showing its type and description.

Variable Documentation

When completing variables inside ${...} expressions, the documentation popup shows details about the selected variable:

• Type — the variable's data type (e.g. string, object, integer)
• Description — a short explanation of the variable's purpose
• Sub-fields — for object-type variables (like initiator, projectInfo, processInfo), the popup lists all available fields with their types and descriptions
• Source — where the variable comes from (e.g. "built-in variable", "flow input parameter", "set step variable")

This is especially useful for built-in object variables. For example, selecting initiator in the completion list and pressing CtrlQ shows its sub-fields (username, displayName, email, groups, attributes) with their types and descriptions -- so you can see exactly what properties are available without leaving the editor.

Quick documentation for a built-in variable showing its type and description.

Property Documentation

When completing properties after a dot (e.g., ${initiator.}), the documentation popup shows details about the selected property:

• Type — the property's data type
• Description — a short explanation of the property's purpose (when available from the schema)
• Sub-fields — for nested object properties, the popup lists their fields

Quick documentation for a property in the completion list, showing its type and description.

How to Use

Simply start typing, and the completion list will appear automatically.

• Force Open: Press CtrlSpace to show suggestions at any time.
• Select Item: Use the arrow keys to navigate and Enter or Tab to insert the selected item.
• Documentation: While the completion list is open, press CtrlQ to see a quick description of the selected key (if available).

Example

Autocomplete in Action

Writing a call step becomes much faster as the plugin suggests available flows and their input and output parameters:

Try it yourself

Type cal and press Enter to create a call step, then use CtrlSpace to see available flow names.

Context-aware completion for Concord YAML keys and flow names.

Smart Type Completion

The plugin is smart enough to know that mandatory and optional only make sense in certain parts of a documentation block, filtering out irrelevant suggestions.