Merge branch 'feature/heuristic-mappings'

# Conflicts:
#	model/smart-impl/src/main/java/com/evolveum/midpoint/smart/impl/activities/MappingsSuggestionRemoteServiceCallActivityRun.java

Author: Michal Zelencik

model/smart-api/src/main/java/com/evolveum/midpoint/smart/api/SmartIntegrationService.java

@@ -203,6 +203,7 @@ MappingsSuggestionType suggestMappings(
             ResourceObjectTypeIdentification typeIdentification,
             SchemaMatchResultType schemaMatch,
             Boolean isInbound,
+            Boolean useAiService,
             @Nullable List<ItemPath> targetPathsToIgnore,
             @Nullable CurrentActivityState<?> activityState,
             Task task,

model/smart-impl/src/main/java/com/evolveum/midpoint/smart/impl/MappingSuggestionOperationFactory.java

@@ -7,6 +7,7 @@
 import com.evolveum.midpoint.schema.result.OperationResult;
 import com.evolveum.midpoint.smart.api.ServiceClient;
 import com.evolveum.midpoint.smart.impl.wellknownschemas.WellKnownSchemaService;
+import com.evolveum.midpoint.smart.impl.mappings.heuristics.HeuristicRuleMatcher;
 import com.evolveum.midpoint.smart.impl.scoring.MappingsQualityAssessor;
 import com.evolveum.midpoint.task.api.Task;
 import com.evolveum.midpoint.util.exception.CommunicationException;
@@ -22,21 +23,30 @@ public class MappingSuggestionOperationFactory {
     private final MappingsQualityAssessor mappingsQualityAssessor;
     private final OwnedShadowsProvider ownedShadowsProvider;
     private final WellKnownSchemaService wellKnownSchemaService;
+    private final HeuristicRuleMatcher heuristicRuleMatcher;
 
     public MappingSuggestionOperationFactory(MappingsQualityAssessor mappingsQualityAssessor,
             OwnedShadowsProvider ownedShadowsProvider,
-            WellKnownSchemaService wellKnownSchemaService) {
+            WellKnownSchemaService wellKnownSchemaService,
+            HeuristicRuleMatcher heuristicRuleMatcher) {
         this.mappingsQualityAssessor = mappingsQualityAssessor;
         this.ownedShadowsProvider = ownedShadowsProvider;
         this.wellKnownSchemaService = wellKnownSchemaService;
+        this.heuristicRuleMatcher = heuristicRuleMatcher;
     }
 
     public MappingsSuggestionOperation create(ServiceClient client, String resourceOid,
             ResourceObjectTypeIdentification typeIdentification, CurrentActivityState<?> activityState,
-            boolean isInbound, Task task, OperationResult parentResult)
+            boolean isInbound, boolean useAiService, Task task, OperationResult parentResult)
             throws SchemaException, ExpressionEvaluationException, SecurityViolationException, CommunicationException,
             ConfigurationException, ObjectNotFoundException {
-        return MappingsSuggestionOperation.init(client, resourceOid, typeIdentification, activityState,
-                this.mappingsQualityAssessor, this.ownedShadowsProvider, this.wellKnownSchemaService, isInbound, task, parentResult);
+        return MappingsSuggestionOperation.init(
+                TypeOperationContext.init(client, resourceOid, typeIdentification, activityState, task, parentResult),
+                this.mappingsQualityAssessor,
+                this.ownedShadowsProvider,
+                this.wellKnownSchemaService,
+                this.heuristicRuleMatcher,
+                isInbound,
+                useAiService);
     }
 }

model/smart-impl/src/main/java/com/evolveum/midpoint/smart/impl/MappingsSuggestionOperation.java

@@ -576,6 +576,7 @@ public MappingsSuggestionType suggestMappings(
             ResourceObjectTypeIdentification typeIdentification,
             SchemaMatchResultType schemaMatch,
             Boolean isInbound,
+            Boolean useAiService,
             @Nullable List<ItemPath> targetPathsToIgnore,
             @Nullable CurrentActivityState<?> activityState,
             Task task,
@@ -589,7 +590,7 @@ public MappingsSuggestionType suggestMappings(
                 .build();
         try (var serviceClient = this.clientFactory.getServiceClient(result)) {
             var mappings = this.mappingSuggestionOperationFactory.create(serviceClient, resourceOid,
-                    typeIdentification, activityState, isInbound, task, result)
+                    typeIdentification, activityState, isInbound, useAiService, task, result)
                     .suggestMappings(result, schemaMatch, targetPathsToIgnore);
             LOGGER.debug("Suggested mappings:\n{}", mappings.debugDumpLazily(1));
             return mappings;

model/smart-impl/src/main/java/com/evolveum/midpoint/smart/impl/SmartIntegrationServiceImpl.java

@@ -44,7 +44,7 @@ protected MappingsSuggestionRemoteServiceCallActivityRun(@NotNull ActivityRunIns
         var isInbound = getWorkDefinition().isInbound();
 
         var suggestedMappings = SmartIntegrationBeans.get().smartIntegrationService.suggestMappings(
-                resourceOid, typeDef, schemaMatch, isInbound, targetPathsToIgnore, state, task, result);
+                resourceOid, typeDef, schemaMatch, isInbound, true, targetPathsToIgnore, state, task, result);
 
         parentState.setWorkStateItemRealValues(MappingsSuggestionWorkStateType.F_RESULT, suggestedMappings);
         parentState.flushPendingTaskModifications(result);

model/smart-impl/src/main/java/com/evolveum/midpoint/smart/impl/activities/MappingsSuggestionRemoteServiceCallActivityRun.java

@@ -75,7 +75,7 @@ public boolean isSourceDataMissing(float missingDataThreshold) {
     /**
      * Checks if all source values match their corresponding target values after type conversion.
      */
-    public boolean doAllConvertedSourcesMatchTargets(
+    public boolean allSourcesMatchTargets(
             PrismObjectDefinition<?> focusTypeDefinition,
             ResourceObjectTypeDefinition objectTypeDefinition,
             Protector protector) {

model/smart-impl/src/main/java/com/evolveum/midpoint/smart/impl/mappings/ValuesPairSample.java

@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2026 Evolveum and contributors
+ *
+ * Licensed under the EUPL-1.2 or later.
+ *
+ */
+
+package com.evolveum.midpoint.smart.impl.mappings.heuristics;
+
+import com.evolveum.midpoint.smart.impl.mappings.ValuesPairSample;
+import com.evolveum.midpoint.xml.ns._public.common.common_3.ExpressionType;
+
+import org.springframework.stereotype.Component;
+
+/**
+ * Heuristic that extracts the first word from the input.
+ * Useful for extracting given names from full names or first part of compound identifiers.
+ */
+@Component
+public class FirstWordHeuristic implements HeuristicRule {
+
+    @Override
+    public String getName() {
+        return "firstWord";
+    }
+
+    @Override
+    public String getDescription() {
+        return "Extract first word from input";
+    }
+
+    /**
+     * Only applicable if source values contain spaces (multi-word strings).
+     */
+    @Override
+    public boolean isApplicable(ValuesPairSample<?, ?> sample) {
+        return sample.pairs().stream()
+                .flatMap(pair -> pair.getSourceValues(sample.direction()).stream())
+                .filter(value -> value instanceof String)
+                .map(value -> (String) value)
+                .anyMatch(str -> str != null && str.trim().contains(" "));
+    }
+
+    @Override
+    public ExpressionType inboundExpression(MappingExpressionFactory factory) {
+        return factory.createScriptExpression(
+                "input?.split('\\\\s+')[0]",
+                "Extract first word");
+    }
+
+    @Override
+    public ExpressionType outboundExpression(String focusPropertyName, MappingExpressionFactory factory) {
+        return factory.createScriptExpression(
+                focusPropertyName + "?.split('\\\\s+')[0]",
+                "Extract first word");
+    }
+}

model/smart-impl/src/main/java/com/evolveum/midpoint/smart/impl/mappings/heuristics/FirstWordHeuristic.java

@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2026 Evolveum and contributors
+ *
+ * Licensed under the EUPL-1.2 or later.
+ *
+ */
+
+package com.evolveum.midpoint.smart.impl.mappings.heuristics;
+
+import com.evolveum.midpoint.xml.ns._public.common.common_3.ExpressionType;
+
+/**
+ * Result of attempting to apply a heuristic mapping.
+ */
+public record HeuristicResult(
+        String heuristicName,
+        ExpressionType expression,
+        float quality) {
+}

model/smart-impl/src/main/java/com/evolveum/midpoint/smart/impl/mappings/heuristics/HeuristicResult.java

@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2026 Evolveum and contributors
+ *
+ * Licensed under the EUPL-1.2 or later.
+ *
+ */
+
+package com.evolveum.midpoint.smart.impl.mappings.heuristics;
+
+import com.evolveum.midpoint.smart.impl.mappings.ValuesPairSample;
+import com.evolveum.midpoint.xml.ns._public.common.common_3.ExpressionType;
+
+/**
+ * Represents a simple transformation rule that can be applied to attribute mappings.
+ * Rules are combined algorithmically by the heuristic manager to find the best fit.
+ *
+ * Rules are simple, fast transformations like toLowerCase(), trim(), etc.
+ * that can be validated against sample data to determine if they produce correct mappings.
+ */
+public interface HeuristicRule {
+
+    /**
+     * Returns a unique name for this rule (e.g., "toLowerCase", "trim").
+     */
+    String getName();
+
+    /**
+     * Returns a human-readable description of what this rule does.
+     */
+    String getDescription();
+
+    /**
+     * Checks if this rule is potentially applicable to the given sample data.
+     * This is a quick pre-filter to avoid expensive quality assessment for obviously incompatible rules.
+     */
+    boolean isApplicable(ValuesPairSample<?, ?> sample);
+
+    /**
+     * Creates the expression for inbound mapping using the provided factory.
+     * Uses 'input' as the variable name for the source shadow attribute.
+     * Returns null if this rule represents "asIs" mapping (no transformation).
+     *
+     * @param factory the factory to create the expression
+     * @return the expression or null for no transformation
+     */
+    ExpressionType inboundExpression(MappingExpressionFactory factory);
+
+    /**
+     * Creates the expression for outbound mapping using the provided factory.
+     * Uses the actual focus property name as the variable (e.g., 'personalNumber', 'givenName').
+     * Returns null if this rule represents "asIs" mapping (no transformation).
+     *
+     * @param focusPropertyName the name of the focus property
+     * @param factory the factory to create the expression
+     * @return the expression or null for no transformation
+     */
+    ExpressionType outboundExpression(String focusPropertyName, MappingExpressionFactory factory);
+}

model/smart-impl/src/main/java/com/evolveum/midpoint/smart/impl/mappings/heuristics/HeuristicRule.java

@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) 2026 Evolveum and contributors
+ *
+ * Licensed under the EUPL-1.2 or later.
+ *
+ */
+
+package com.evolveum.midpoint.smart.impl.mappings.heuristics;
+
+import java.util.List;
+import java.util.Optional;
+
+import com.evolveum.midpoint.schema.result.OperationResult;
+import com.evolveum.midpoint.smart.impl.mappings.MappingDirection;
+import com.evolveum.midpoint.smart.impl.mappings.ValuesPairSample;
+import com.evolveum.midpoint.smart.impl.scoring.MappingsQualityAssessor;
+import com.evolveum.midpoint.task.api.Task;
+import com.evolveum.midpoint.util.exception.ExpressionEvaluationException;
+import com.evolveum.midpoint.util.exception.SecurityViolationException;
+import com.evolveum.midpoint.util.logging.Trace;
+import com.evolveum.midpoint.util.logging.TraceManager;
+import com.evolveum.midpoint.xml.ns._public.common.common_3.ExpressionType;
+import com.evolveum.midpoint.xml.ns._public.common.common_3.ObjectFactory;
+import com.evolveum.midpoint.xml.ns._public.common.common_3.ScriptExpressionEvaluatorType;
+
+import org.springframework.stereotype.Component;
+
+@Component
+public class HeuristicRuleMatcher {
+
+    private static final Trace LOGGER = TraceManager.getTrace(HeuristicRuleMatcher.class);
+
+    private final List<HeuristicRule> rules;
+    private final MappingsQualityAssessor qualityAssessor;
+
+    public HeuristicRuleMatcher(List<HeuristicRule> rules, MappingsQualityAssessor qualityAssessor) {
+        this.rules = rules;
+        this.qualityAssessor = qualityAssessor;
+    }
+
+    /**
+     * Static factory method for creating script expressions.
+     * Used as a method reference passed to heuristic rules.
+     */
+    private static ExpressionType createScriptExpression(String groovyCode, String description) {
+        return new ExpressionType()
+                .description(description)
+                .expressionEvaluator(
+                        new ObjectFactory().createScript(
+                                new ScriptExpressionEvaluatorType().code(groovyCode)));
+    }
+
+    /**
+     * Attempts to find the best heuristic rule.
+     * All rules are evaluated, and the one with the highest quality (higher than zero) is returned.
+     */
+    public Optional<HeuristicResult> findBestMatch(ValuesPairSample<?, ?> sample, Task task, OperationResult result) {
+        HeuristicRule bestRule = null;
+        ExpressionType bestExpression = null;
+        float bestQuality = 0f;
+
+        for (HeuristicRule rule : rules) {
+            if (!rule.isApplicable(sample)) {
+                continue;
+            }
+
+            LOGGER.trace("Evaluating rule: {}", rule.getName());
+            ExpressionType expression = generateExpression(rule, sample);
+
+            try {
+                var assessment = qualityAssessor.assessMappingsQuality(sample, expression, task, result);
+                if (assessment == null || assessment.status() != MappingsQualityAssessor.AssessmentStatus.OK) {
+                    continue;
+                }
+
+                float quality = assessment.quality();
+                LOGGER.debug("Rule '{}' quality: {}", rule.getName(), quality);
+
+                if (quality > bestQuality) {
+                    LOGGER.debug("New best rule '{}' with quality {}", rule.getName(), quality);
+                    bestRule = rule;
+                    bestExpression = expression;
+                    bestQuality = quality;
+                }
+            } catch (ExpressionEvaluationException | SecurityViolationException e) {
+                LOGGER.debug("Rule '{}' evaluation failed: {}", rule.getName(), e.getMessage());
+            }
+        }
+
+        if (bestRule != null) {
+            LOGGER.info("Best rule '{}' with quality {}", bestRule.getName(), bestQuality);
+            return Optional.of(new HeuristicResult(bestRule.getName(), bestExpression, bestQuality));
+        }
+
+        return Optional.empty();
+    }
+
+
+    private ExpressionType generateExpression(HeuristicRule rule, ValuesPairSample<?, ?> sample) {
+        if (sample.direction() == MappingDirection.INBOUND) {
+            return rule.inboundExpression(HeuristicRuleMatcher::createScriptExpression);
+        } else {
+            String focusPropertyName = sample.focusPropertyPath().lastName().getLocalPart();
+            return rule.outboundExpression(focusPropertyName, HeuristicRuleMatcher::createScriptExpression);
+        }
+    }
+}