fix: search incidents by errorMessage with wildcard returns no results

The Camunda 8 incident search API does not support $like filter
objects for the errorMessage field. When a wildcard pattern was passed
via --errorMessage, toStringFilter() converted it to { $like: '...' },
which the API silently ignored, returning 0 results.

Fix: detect wildcard patterns in errorMessage and fall back to
client-side filtering (fetching up to CI_PAGE_SIZE results and
filtering locally using case-sensitive pattern matching).

Plain strings (no wildcards) are still passed to the API for
server-side exact matching as before.

Also adds:
- matchesCaseSensitive helper for case-sensitive wildcard matching
- wildcardToRegex optional caseInsensitive parameter (default true)
- Unit tests for new case-sensitive matching behaviour

Co-authored-by: vobu <6573426+vobu@users.noreply.github.com>

Author: Copilot

src/commands/search.ts

@@ -27,7 +27,7 @@ export const toStringFilter = (value: string): string | { $like: string } =>
  * Convert a wildcard pattern (* and ?) to a case-insensitive RegExp.
  * Handles escaped wildcards (\* and \?).
  */
-export const wildcardToRegex = (pattern: string): RegExp => {
+export const wildcardToRegex = (pattern: string, caseInsensitive = true): RegExp => {
   let regex = '';
   for (let i = 0; i < pattern.length; i++) {
     if (pattern[i] === '\\' && i + 1 < pattern.length && (pattern[i + 1] === '*' || pattern[i + 1] === '?')) {
@@ -41,7 +41,7 @@ export const wildcardToRegex = (pattern: string): RegExp => {
       regex += pattern[i].replace(/[[\]{}()+.,\\^$|#]/g, '\\$&');
     }
   }
-  return new RegExp(`^${regex}$`, 'i');
+  return new RegExp(`^${regex}$`, caseInsensitive ? 'i' : '');
 };
 
 /**
@@ -53,6 +53,15 @@ export const matchesCaseInsensitive = (value: string | undefined | null, pattern
   return wildcardToRegex(pattern).test(value);
 };
 
+/**
+ * Test if a value matches a wildcard pattern case-sensitively.
+ * Without wildcards, performs exact case-sensitive match.
+ */
+export const matchesCaseSensitive = (value: string | undefined | null, pattern: string): boolean => {
+  if (value == null) return false;
+  return wildcardToRegex(pattern, false).test(value);
+};
+
 const toBigIntSafe = (value: unknown): bigint => {
   try {
     return BigInt(String(value));
@@ -431,7 +440,9 @@ export async function searchIncidents(options: {
   const logger = getLogger();
   const client = createClient(options.profile);
   const tenantId = resolveTenantId(options.profile);
-  const hasCiFilter = !!(options.iErrorMessage || options.iProcessDefinitionId);
+  // The incident API does not support a $like filter for errorMessage; fall back to client-side filtering for wildcard patterns
+  const errorMessageHasWildcard = !!(options.errorMessage && hasUnescapedWildcard(options.errorMessage));
+  const hasCiFilter = !!(options.iErrorMessage || options.iProcessDefinitionId || errorMessageHasWildcard);
 
   // Build search criteria description for user feedback
   const criteria: string[] = [];
@@ -486,8 +497,8 @@ export async function searchIncidents(options: {
       filter.filter.errorType = options.errorType;
     }
 
-    if (options.errorMessage) {
-      filter.filter.errorMessage = toStringFilter(options.errorMessage);
+    if (options.errorMessage && !errorMessageHasWildcard) {
+      filter.filter.errorMessage = options.errorMessage;
     }
 
     if (options.processDefinitionId) {
@@ -500,6 +511,7 @@ export async function searchIncidents(options: {
       result.items = result.items.filter((incident: any) => {
         if (options.iErrorMessage && !matchesCaseInsensitive(incident.errorMessage, options.iErrorMessage)) return false;
         if (options.iProcessDefinitionId && !matchesCaseInsensitive(incident.processDefinitionId, options.iProcessDefinitionId)) return false;
+        if (errorMessageHasWildcard && options.errorMessage && !matchesCaseSensitive(incident.errorMessage, options.errorMessage)) return false;
         return true;
       });
     }

tests/unit/search-wildcard.test.ts

@@ -4,7 +4,7 @@
 
 import { test, describe } from 'node:test';
 import assert from 'node:assert';
-import { toStringFilter, wildcardToRegex, matchesCaseInsensitive, hasUnescapedWildcard } from '../../src/commands/search.ts';
+import { toStringFilter, wildcardToRegex, matchesCaseInsensitive, matchesCaseSensitive, hasUnescapedWildcard } from '../../src/commands/search.ts';
 
 describe('toStringFilter — wildcard detection', () => {
   test('plain string returns the string as-is', () => {
@@ -111,11 +111,55 @@ describe('wildcardToRegex — pattern conversion', () => {
     assert.ok(!regex.test('myXprocessXv1'));
   });
 
-  test('complex mixed pattern', () => {
-    const regex = wildcardToRegex('*-v?.bpmn');
-    assert.ok(regex.test('process-v1.bpmn'));
-    assert.ok(regex.test('PROCESS-V2.BPMN'));
-    assert.ok(!regex.test('process-v12.bpmn'));
+  test('case-sensitive mode rejects wrong case', () => {
+    const regex = wildcardToRegex('hello', false);
+    assert.ok(regex.test('hello'));
+    assert.ok(!regex.test('HELLO'));
+    assert.ok(!regex.test('Hello'));
+  });
+
+  test('case-sensitive mode with wildcard', () => {
+    const regex = wildcardToRegex('Assertion*', false);
+    assert.ok(regex.test('Assertion failure'));
+    assert.ok(!regex.test('assertion failure'));
+    assert.ok(!regex.test('ASSERTION FAILURE'));
+  });
+});
+
+describe('matchesCaseSensitive — value matching', () => {
+  test('exact match requires correct case', () => {
+    assert.ok(matchesCaseSensitive('OrderProcess', 'OrderProcess'));
+    assert.ok(!matchesCaseSensitive('OrderProcess', 'orderprocess'));
+    assert.ok(!matchesCaseSensitive('OrderProcess', 'ORDERPROCESS'));
+  });
+
+  test('wildcard match respects case', () => {
+    assert.ok(matchesCaseSensitive('Assertion failure on evaluate', 'Assertion*'));
+    assert.ok(!matchesCaseSensitive('Assertion failure on evaluate', 'assertion*'));
+    assert.ok(matchesCaseSensitive('Assertion failure on evaluate', '*failure*'));
+    assert.ok(!matchesCaseSensitive('Assertion failure on evaluate', '*FAILURE*'));
+  });
+
+  test('returns false for null or undefined', () => {
+    assert.ok(!matchesCaseSensitive(null, 'test'));
+    assert.ok(!matchesCaseSensitive(undefined, 'test'));
+  });
+
+  test('returns false when pattern does not match', () => {
+    assert.ok(!matchesCaseSensitive('OrderProcess', 'payment*'));
+    assert.ok(!matchesCaseSensitive('hello', 'world'));
+  });
+
+  test('empty pattern matches empty value', () => {
+    assert.ok(matchesCaseSensitive('', ''));
+  });
+
+  test('empty pattern does not match non-empty value', () => {
+    assert.ok(!matchesCaseSensitive('hello', ''));
+  });
+
+  test('non-empty pattern does not match empty value', () => {
+    assert.ok(!matchesCaseSensitive('', 'hello'));
   });
 });