Expression Function Completion​

Inside ${...} expressions, pressing CtrlSpace now suggests Concord's built-in functions alongside variables. Each suggestion shows a method icon, the function name, its signature, and return type. Parentheses are inserted automatically — with the caret placed inside for functions that take parameters.

Available functions include hasVariable(), hasNonNullVariable(), orDefault(), currentFlowName(), allVariables(), hasFlow(), uuid(), and others.

Expression Task Method Completion​

When you type a dot after a task name in a ${...} expression (e.g., ${datetime.}), the plugin now suggests the public methods available on that task. Method signatures are extracted from the task's dependency JAR at the bytecode level, so they reflect the actual Java API.

Required Flow Parameters Check​

When you run a flow that has mandatory input parameters (declared in a flow documentation block), the plugin now checks whether all required parameters have values before execution. If any are missing, it opens the Run Configuration dialog with the missing parameter rows pre-filled, so you can provide values before the flow starts.

Repository Settings​

A new Settings | Tools | Concord | Repositories page lets you manage Maven repositories directly from the IDE. The plugin reads and writes Concord CLI's ~/.concord/mvn.json file, so the IDE and CLI always share the same repository configuration.

Each repository supports authentication, release/snapshot policies, and proxy settings. If no repositories are configured, the plugin falls back to Maven Central.

Other Improvements​

• Resources Pattern Inspection: Invalid glob or regex patterns in resources.concord lists are now flagged with a warning, catching typos and syntax errors before runtime.
• Configurable Target Directory: The target directory for CLI execution (default .concord/target) is now configurable in Settings | Tools | Concord Run Mode. The directory is automatically excluded from IntelliJ's indexing.
• Call Output Variable Completion: Output parameters from call steps are now available as variable suggestions in ${...} expressions within the same step's out block.
• EL Task Name Completion: Task names from project dependencies are now suggested inside ${...} expressions, with class icons to distinguish them from variables and functions.

Expression Language Support​

Concord ${...} expressions are now first-class citizens in the editor, with full IDE support from highlighting through navigation.

EL Highlighting​

Expression delimiters ${ and } are highlighted at the lexer level, providing accurate, real-time coloring as you type — including inline strings, multiple expressions, and nested braces.

Variable Completion​

Press CtrlSpace inside a ${...} expression to see all variables in scope. Each suggestion shows the variable name, its source (e.g. built-in, set, flow in, step out), and its type when known. Completion is context-aware — only variables visible at the current step are suggested.

Property Completion​

After typing a dot in an expression (e.g. ${initiator.}), the plugin suggests available sub-properties based on the variable's schema. This works for built-in variables, task output, and any variable whose structure can be inferred from the YAML.

Go to Declaration & Find Usages​

Ctrl + Click on a variable in a ${...} expression to jump to its declaration — whether it's a key in configuration.arguments, a parameter in a flow doc block, a set step, or an out field of a task/call step. The same works in reverse: place the caret on a variable declaration and press AltF7 to find every expression that references it.

Navigation also works for nested properties — clicking host in ${config.db.host} walks the property chain to the corresponding YAML key.

Variable Schema Inference​

The plugin now infers variable types from multiple sources across your flow, enabling typed completion and property suggestions for ${...} expressions:

• set steps — Variables assigned in set steps have their structure inferred from the YAML mapping values.
• configuration.arguments — Arguments declared at the top level are tracked with their types.
• call step out — Output variables from a call step are inferred from the target flow's documentation block.
• task step out — Output variables from a task step are inferred from the task's JSON schema.

Call Output Parameter Completion​

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

JDK Selection for Concord CLI​

You can now select a specific JDK for running the Concord CLI, independent of the project SDK. This is useful when your project targets a different Java version than what Concord requires.

Configure it in Settings > Tools > Concord > CLI.

Other Improvements​

• Stale Highlighting Fix: The analysis daemon now restarts on external VFS changes, preventing stale highlighting after files are modified outside the IDE.

Hover Documentation​

You can now press CtrlQ on any Concord element to see contextual documentation without leaving the editor.

Flow Call Documentation​

Hovering over a flow name in a call step shows the flow's description, input/output parameters with types, required/optional flags, and descriptions — all extracted from the target flow's documentation block.

Task Documentation​

Hovering over a task name shows its full description along with input/output parameters, types, and enum values — powered by built-in task schemas. For tasks with conditional parameters (e.g. different params for action: start vs action: fork), the popup groups them intelligently.

YAML Key Documentation​

Hovering over any Concord YAML key — top-level sections, step types, and their properties — shows a description of that key's purpose in context.

Task Schema System​

A new JSON Schema-based system powers intelligent completion and validation for task step parameters.

• Parameter Completion: The plugin suggests valid in parameter names for known tasks as you type.
• Enum Value Completion: For parameters that accept a fixed set of values (e.g. action, method), the allowed options are suggested.
• Conditional Parameters: Suggestions adapt based on already specified values. After setting action: start, only parameters relevant to the start action are suggested.
• Validation: Unknown keys and invalid values inside task in/out blocks are flagged by inspections.

The initial release ships with the built-in concord task schema. More task schemas will be added in future releases.

Quick Documentation in Completion​

While the completion list is open, you can now press CtrlQ to preview documentation for the selected item without accepting it. This works for YAML keys, task names, and task parameters.

Server-Only Dependency Inspection​

Dependencies that use version strings like latest — resolved at runtime by the Concord server but not by the IDE locally — are now detected and flagged with a weak warning. The plugin offers a quick fix that adds a concrete version to the cli profile, giving the IDE what it needs without affecting server execution.

Other Improvements​

• Tool Window Icon: Fixed the tool window icon to use proper SVG format.

Concord Tool Window​

A new dedicated tool window gives you an at-a-glance overview of your Concord project structure. The tree displays your scopes, root files, dependencies, and resources in a single panel.

• Navigate Instantly: Double-click any item to jump directly to its source.
• Always Up-to-Date: The tree automatically refreshes when project files change.
• Scope Awareness: Each scope is displayed as a top-level node, making it easy to work with monorepos.

Dependency Management​

Task Name Completion​

The plugin now scans Maven dependencies declared in your concord.yaml and extracts @Named task names from JARs. This means you get scope-aware autocompletion for task step values—no more guessing task names or hunting through documentation.

Dependency Error Reporting​

Unresolved dependencies are now surfaced directly in the editor as inline inspections, so you can spot configuration problems without leaving your flow file. Errors are also reported in the Build Sync tab with clickable navigation, and problem files are marked red in the Project tree.

Related Symbol Navigation​

You can now navigate from any Concord file to its associated root concord.yaml file. This is especially useful in large projects where resource files are deeply nested.

• Shortcut: CtrlAltHome
• Menu: Go to Navigate > Related Symbol

If a file belongs to multiple scopes, a popup will let you choose which root to navigate to.

Other Improvements​

• Scope-Strict Flow Completion: Flow completion now strictly respects the search scope, preventing suggestions from leaking across project boundaries.

Run Configurations​

You can now execute Concord flows locally directly from the IDE. This feature is powered by the Concord CLI, enabling rapid feedback loops during development without needing to push changes to a server.

The easiest way to start a flow is by using the Run icon in the editor gutter next to the flow definition. You can also right-click a flow name and select Run.

Key Features:​

• Interactive Console: The output supports ANSI colors and clickable hyperlinks that take you directly to the source code on errors.
• Automatic CLI Management: The plugin can automatically download and configure the Concord CLI for you.
• Flexible Configuration: Customize execution with parameters, working directory, and different modes to fit your workflow.

Language Injection​

Writing scripts inside YAML has always been a challenge—until now. The plugin now automatically detects and injects the appropriate language into script steps.

Whether you are writing Groovy, JavaScript, Python, or Ruby, you now get full IDE support directly inside your Concord files:

• Syntax Highlighting: No more plain text blocks. Code is colored and formatted correctly.
• Code Completion: Access standard library functions and Concord implicit variables.
• Inspections: Catch syntax errors in your scripts before running them.

Improved Navigation & Icons​

We've added a dedicated Icon Provider for Concord files. Your Concord elements now have distinct icons in the Project View, Structure View, and Navigation popups, making it easier to distinguish between:

• Flow
• Trigger
• Form

Scope Safety Inspections​

Working in a monorepo can get messy. The plugin now includes an inspection to warn you if a file is Outside of Scope.

If you open a .concord.yaml file that isn't part of a defined Concord project (root or resource), the IDE will notify you. This prevents confusion when features like navigation or completion seem "broken" simply because the file isn't being indexed as part of the project context.

Breadcrumbs​

Navigating through deeply nested YAML structures is now much easier. The plugin now integrates with the IDE's Breadcrumbs component to show your current location within a .concord.yaml file.

The breadcrumbs bar at the bottom of the editor provides a clear path from the file root to your current element, such as the active flow and the specific step you are editing. This is especially helpful when dealing with complex, multi-step flows.

Gitignore Support​

The plugin now respects .gitignore rules during Concord file discovery and scope resolution. This ensures that ignored files and directories (like build artifacts or temporary files) are excluded from the project's scope, making completion, navigation, and search results more accurate and relevant to your source code.

Other Improvements​

• Completion Fixes: Improved reliability of completion functionality in multi-scope projects.

Call Hierarchy​

Understanding flow dependencies is critical for impact analysis. The new Call Hierarchy view allows you to visualize caller-callee relationships as a hierarchical tree.

You can now instantly answer questions like:

• "Which flows call this common utility?" (Caller Hierarchy)
• "What is the complete execution chain of this main process?" (Callee Hierarchy)

Rename Refactoring​

Renaming a flow across a large project used to be error-prone. With the new Rename Refactoring, you can safely rename a flow definition, and the plugin will automatically update every call referencing it within the current scope.

• Safe: Updates strictly confined to the project scope.
• Preview: Review all changes before applying them.
• Shortcut: Just press ShiftF6 on any flow name.

Smart Inspections: Duplicate Flows​

Naming collisions can lead to confusing bugs in complex projects. The plugin now includes a Duplicate Flow Name Inspection that warns you if the same flow name is defined multiple times within the same scope.

• Detection: Flags duplicate definitions even across different files.
• Resolution: Provides a Quick Fix to show all conflicting definitions in a Usage View panel, making it easy to decide which one to rename or remove.

Flow Documentation Improvements​

We've significantly enhanced the developer experience for Flow Documentation. Documentation blocks are no longer just static comments—they are now actively maintained by the IDE.

New Quick Fixes​

The plugin now detects and offers one-click fixes for several common documentation issues:

• Missing Parameters: If you use a variable in a flow that isn't documented, the IDE will offer to add it to the in: section automatically.
• Keyword Typos: Automatically correct common misspellings like mandatry or optinal in your documentation blocks.
• Invalid Types: Misspelled types like strnig can now be instantly replaced with valid Concord types from a suggested list.
• Broken Boundaries: A new quick fix helps you restore missing closing ## markers.

Arbitrary Indentation​

Flow documentation blocks now support arbitrary indentation styles. Whether you prefer two spaces, four, or something else, the plugin correctly parses your parameters as long as they are more indented than the section headers.

Multiple Scopes Support​

For teams working with monorepos, we've added full support for Multiple Scopes. The plugin now automatically isolates Concord projects within a single IntelliJ workspace.

• Isolation: References and completion are confined to the current project scope.
• Discovery: concord.yaml files are automatically detected as project roots.
• Search: Global search results now show the scope name (e.g., [billing-service] deploy) to help you distinguish between flows with identical names in different projects.

Enhanced Performance​

This release introduces smarter caching for flow documentation and input parameter resolution. These internal changes significantly reduce the CPU load when working with large files and improve the responsiveness of code completion and navigation.

Semantic Syntax Highlighting​

IDE Compatibility​

This release also updates the plugin to support IntelliJ IDEA 2025.3.1. We recommend updating your IDE to ensure the best performance and compatibility with the new highlighting features.