fix(file): keep long previews honest, credit forced repeats, drop bad hints

Four review findings, each reproduced before it was changed.

A regex match has no length limit, so `abc.*` on a long line produces a match
larger than the whole preview budget. The layout passed it through whole and
let the final byte cap cut it, which removed the closing marker along with the
text — 2048 bytes of output ending mid-line with nothing to say so. The match
is now clipped against a budget that reserves that marker, and a clipped match
always carries one.

A variable repeat was scored at one occurrence when its minimum forces more:
`(?:ab){2,5}` cannot match without `abab` in it, but the run was counted as 2
and the pattern rejected against a gate of 3. It now contributes the copies its
minimum forces.

`\Y`, `\m` and `\M` were rejected with a suggestion to write `\b`, `^` or `$`.
Those are different assertions — a non-boundary, and two word edges rather than
the line's — so the hint handed back different semantics as a fix. They now say
no supported escape means the same thing. `\y`, `\A` and `\Z` keep theirs,
which are genuine.

Smart case was documented as reacting to any uppercase letter, but it reads
literals only, so `\D` and `[A-Z]` do not make a search case-sensitive. The
tool, block and generated docs now say what the code does.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: icecrasher321

apps/docs/content/docs/integrations/file.mdx

@@ -76,7 +76,7 @@ Search every active workspace file for lines matching a regular expression, and
 
 | Parameter | Type | Required | Description |
 | --------- | ---- | -------- | ----------- |
-| `query` | string | Yes | A regular expression matched against each line, 3-512 characters. Supports "." "*" "+" "?" "\{n,m\}" and their lazy forms, character classes such as "\[a-z\]" and "\[^0-9\]", the classes \d \w \s and \D \W \S, alternation "\|", groups "\(...\)" and "\(?:...\)", the anchors "^" and "$", and the word boundary \b. Lookahead, lookbehind, backreferences, named groups, inline flags such as "\(?i\)", \p\{...\} and POSIX "\[\[:alpha:\]\]" classes are not supported, and a pattern cannot span a line break. The pattern must contain at least 3 consecutive literal characters that every match will include — write "error \d+" rather than "\w+ \d+". Escape any metacharacter you mean literally. Matching is case-insensitive until the pattern contains an uppercase letter, which makes it case-sensitive. |
+| `query` | string | Yes | A regular expression matched against each line, 3-512 characters. Supports "." "*" "+" "?" "\{n,m\}" and their lazy forms, character classes such as "\[a-z\]" and "\[^0-9\]", the classes \d \w \s and \D \W \S, alternation "\|", groups "\(...\)" and "\(?:...\)", the anchors "^" and "$", and the word boundary \b. Lookahead, lookbehind, backreferences, named groups, inline flags such as "\(?i\)", \p\{...\} and POSIX "\[\[:alpha:\]\]" classes are not supported, and a pattern cannot span a line break. The pattern must contain at least 3 consecutive literal characters that every match will include — write "error \d+" rather than "\w+ \d+". Escape any metacharacter you mean literally. Matching is case-insensitive until the pattern contains an uppercase letter you are searching for; uppercase inside an escape or a character class, such as \D or \[A-Z\], does not make it case-sensitive. |
 | `mode` | string | No | How the query is read, chosen by the workflow builder: "regex" \(default\) as a regular expression, or "exact" as verbatim text. |
 | `maxResults` | number | No | Hard result cap configured by the workflow builder \(1-200, default 50\). |
 

apps/sim/blocks/blocks/file.ts

@@ -908,7 +908,7 @@ export const FileV5Block: BlockConfig<FileParserV3Output> = {
   - Get Content is how you read file text. It accepts file objects or canonical file IDs and returns a "contents" array with one extracted text string per file (PDF, DOCX, CSV, etc. are parsed automatically).
   - To read the text of files produced by another block, chain into Get Content: set its file input to the upstream file output, e.g. <file.files>, <agent.files>, or <start.files>. Never assume Read (or any file-object output) already contains the text.
   - Get Content's "contents" can be large; it is persisted through the execution large-value system automatically, so prefer it over inlining file text any other way.
-  - Search finds text across all active workspace files and returns structured results with fileId, lineNumber, and text. Lowercase queries are case-insensitive; adding any uppercase letter makes the search case-sensitive.
+  - Search finds text across all active workspace files and returns structured results with fileId, lineNumber, and text. Queries are case-insensitive until they contain an uppercase letter being searched for; in a regular expression, uppercase inside an escape or character class such as \\D or [A-Z] does not affect this.
   - Search reads the query as a line-oriented regular expression: quantifiers, character classes, \\d \\w \\s, alternation, groups, "^" and "$" anchors, and \\b word boundaries. Lookaround, backreferences and patterns spanning a line break are not supported, and a pattern needs at least 3 consecutive literal characters that every match will contain. Set Match to "Exact match" to search for the query text verbatim instead.
   - Match is a builder setting, not an agent one: the agent writes the query, and Match decides how every query from that block is read.
   - Search is eventually consistent. Check "complete" and "indexStatus" when pending, failed, skipped, or partially indexed files matter to the task.

apps/sim/lib/workspace-files/search/regex.test.ts

@@ -30,7 +30,15 @@ describe('analyzeFileSearchRegex', () => {
       expect(run('(?:xyz)?ab')).toBe(2)
       expect(run('foo+bar')).toBe(4)
       expect(run('ab{3}cd')).toBe(6)
-      expect(run('ab{2,4}cd')).toBe(3)
+    })
+
+    /** `(?:ab){2,5}` cannot match without `abab` in it, so the run is 4, not 2. */
+    it('credits a variable repeat with the copies its minimum forces', () => {
+      expect(run('(?:ab){2,5}')).toBe(4)
+      expect(run('(?:abc){2,}')).toBe(6)
+      expect(run('ab{2,4}cd')).toBe(4)
+      expect(run('abc*d')).toBe(2)
+      expect(run('foo+bar')).toBe(4)
     })
 
     it('measures a run in characters, not UTF-16 units', () => {
@@ -75,6 +83,10 @@ describe('analyzeFileSearchRegex', () => {
       ['[[:alpha:]]foo', /POSIX class/],
       ['\\p{Lu}foo', /Unicode property/],
       ['\\yfoo\\y', /"\\y" is not supported — write "\\b" instead/],
+      ['\\Afoo\\Z', /"\\A" is not supported — write "\^" instead/],
+      ['a\\Yb needle', /"\\Y" is not supported, and no supported escape means the same thing/],
+      ['a\\mb needle', /"\\m" is not supported, and no supported escape means the same thing/],
+      ['a\\Mb needle', /"\\M" is not supported, and no supported escape means the same thing/],
       ['foo\\qbar', /not a supported escape/],
       ['foo[\\b]bar', /inside "\[\.\.\.\]"/],
       ['foo(bar', /Unclosed "\("/],

apps/sim/lib/workspace-files/search/regex.ts

@@ -65,12 +65,18 @@ const OPAQUE: LiteralGuarantee = {
 /** Escapes whose meaning and spelling are identical in PostgreSQL ARE and JavaScript. */
 const SHARED_ESCAPE_LETTERS = new Set(['d', 'D', 'w', 'W', 's', 'S', 't', 'n', 'r', 'f', 'v'])
 
-/** PostgreSQL-only escapes, rejected so one spelling means one thing in both engines. */
-const POSTGRES_ONLY_ESCAPES: Record<string, string> = {
+/**
+ * PostgreSQL-only escapes, rejected so one spelling means one thing in both
+ * engines. Only the three with a genuine equivalent name one: `\Y` is a
+ * *non*-boundary, and `\m` / `\M` bind to a word edge rather than the line's,
+ * so pointing them at `\b` / `^` / `$` would hand back different semantics
+ * under the guise of a fix.
+ */
+const POSTGRES_ONLY_ESCAPES: Record<string, string | null> = {
   y: '\\b',
-  Y: '\\b',
-  m: '^',
-  M: '$',
+  Y: null,
+  m: null,
+  M: null,
   A: '^',
   Z: '$',
 }
@@ -154,9 +160,14 @@ function alternate(left: LiteralGuarantee, right: LiteralGuarantee): LiteralGuar
 }
 
 /**
- * `atom` repeated between `min` and `max` times. An optional atom guarantees
- * nothing, and a variable count guarantees one occurrence but nothing joined
- * across the repetition — `fo` + `o+` still guarantees `foo`, never `foo…o`.
+ * `atom` repeated between `min` and `max` times.
+ *
+ * An optional atom guarantees nothing. A variable count is not exact, but it
+ * still guarantees `min` copies back to back — every match of `(?:ab){2,5}`
+ * contains `abab` — so a fixed atom contributes that expansion rather than the
+ * single occurrence it would otherwise be scored at. An atom with no fixed
+ * string contributes only what one occurrence guarantees, since nothing joins
+ * across the repetition: `fo` + `o+` guarantees `foo`, never `foo…o`.
  */
 function repeat(atom: LiteralGuarantee, min: number, max: number): LiteralGuarantee {
   if (min === 0) return { ...OPAQUE, zeroWidth: true }
@@ -167,6 +178,17 @@ function repeat(atom: LiteralGuarantee, min: number, max: number): LiteralGuaran
       return { ...literal(expanded), zeroWidth: expanded.length === 0 }
     }
   }
+  if (atom.exact) {
+    const copies = Math.min(min, Math.ceil(FILE_SEARCH_PATTERN_LITERAL_CAP / atom.exact.length))
+    const expanded = atom.exact.repeat(Math.max(1, copies))
+    return {
+      exact: null,
+      prefix: head(expanded),
+      suffix: tail(expanded),
+      best: Math.min(FILE_SEARCH_PATTERN_LITERAL_CAP, runLength(atom.exact) * min),
+      zeroWidth: false,
+    }
+  }
   return {
     exact: null,
     prefix: atom.prefix,
@@ -415,10 +437,12 @@ class FileSearchRegexParser {
         `Backreference "\\${next}" is not supported — repeat the group's pattern instead`
       )
     }
-    const postgresOnly = POSTGRES_ONLY_ESCAPES[next]
-    if (postgresOnly) {
+    if (next in POSTGRES_ONLY_ESCAPES) {
+      const equivalent = POSTGRES_ONLY_ESCAPES[next]
       throw new FileSearchPatternError(
-        `"\\${next}" is not supported — write "${postgresOnly}" instead`
+        equivalent
+          ? `"\\${next}" is not supported — write "${equivalent}" instead`
+          : `"\\${next}" is not supported, and no supported escape means the same thing`
       )
     }
     if (SHARED_ESCAPE_LETTERS.has(next)) return

apps/sim/lib/workspace-files/search/text.test.ts

@@ -79,6 +79,28 @@ describe('workspace file search text utilities', () => {
     ).toBe('…needle and nearby text…')
   })
 
+  /**
+   * A regex match runs to wherever the pattern takes it, so `abc.*` on a long
+   * line produces a match larger than the whole preview budget.
+   */
+  it('marks a preview whose match alone overruns the budget as truncated', () => {
+    const line = `head ${'x'.repeat(500)}abc${'y'.repeat(4000)} tail`
+    const start = line.indexOf('abc')
+    const preview = createFileSearchPreview(
+      line,
+      compileFileSearchPattern('abc.*', 'regex'),
+      2048,
+      {
+        matchRange: { start, end: line.length },
+      }
+    )
+
+    expect(Buffer.byteLength(preview, 'utf8')).toBeLessThanOrEqual(2048)
+    expect(preview.endsWith('…')).toBe(true)
+    expect(preview).toContain('abc')
+    expect(preview).not.toContain('\uFFFD')
+  })
+
   it('truncates extracted text on a UTF-8 boundary', () => {
     const truncated = truncateUtf8ToBytes('abc🙂def', 6)
     expect(truncated).toBe('abc')

apps/sim/lib/workspace-files/search/text.ts

@@ -135,9 +135,20 @@ export function createFileSearchPreview(
   const { start: matchStart, end: matchEnd } = boundaries.matchRange ??
     pattern.findMatchRange(line) ?? { start: 0, end: 0 }
   const leadingEllipsis = boundaries.prefixOmitted || matchStart > 0 ? '…' : ''
-  const trailingEllipsis = boundaries.suffixOmitted || matchEnd < line.length ? '…' : ''
+  /**
+   * A regex match has no length limit — `abc.*` matches to the end of the line —
+   * so the match alone can exceed the budget. Clipping it here, against a budget
+   * that already reserves the closing marker, is what keeps the excerpt honest:
+   * letting the final cap do it would drop that marker along with the text and
+   * leave a truncated line looking complete.
+   */
+  const budgetBeforeMatch = Math.max(0, maxBytes - Buffer.byteLength(`${leadingEllipsis}…`, 'utf8'))
+  const fullMatch = line.slice(matchStart, matchEnd)
+  const match = utf8PrefixWithinBudget(fullMatch, budgetBeforeMatch)
+  const matchClipped = match.length < fullMatch.length
+  const trailingEllipsis =
+    matchClipped || boundaries.suffixOmitted || matchEnd < line.length ? '…' : ''
   const ellipsisBytes = Buffer.byteLength(leadingEllipsis + trailingEllipsis, 'utf8')
-  const match = line.slice(matchStart, matchEnd)
   const matchBytes = Buffer.byteLength(match, 'utf8')
   const surroundingBudget = Math.max(0, maxBytes - ellipsisBytes - matchBytes)
   const beforeBudget = Math.floor(surroundingBudget / 2)
@@ -146,6 +157,8 @@ export function createFileSearchPreview(
   const after = utf8PrefixWithinBudget(line.slice(matchEnd), afterBudget)
   const preview = `${boundaries.prefixOmitted || before.length < matchStart ? '…' : ''}${
     before
-  }${match}${after}${boundaries.suffixOmitted || matchEnd + after.length < line.length ? '…' : ''}`
+  }${match}${after}${
+    matchClipped || boundaries.suffixOmitted || matchEnd + after.length < line.length ? '…' : ''
+  }`
   return utf8PrefixWithinBudget(preview, maxBytes)
 }

apps/sim/tools/file/search.ts

@@ -28,7 +28,7 @@ const TOOL_DESCRIPTIONS: Record<FileSearchMode, string> = {
 
 const QUERY_DESCRIPTIONS: Record<FileSearchMode, string> = {
   regex:
-    'A regular expression matched against each line, 3-512 characters. Supports "." "*" "+" "?" "{n,m}" and their lazy forms, character classes such as "[a-z]" and "[^0-9]", the classes \\d \\w \\s and \\D \\W \\S, alternation "|", groups "(...)" and "(?:...)", the anchors "^" and "$", and the word boundary \\b. Lookahead, lookbehind, backreferences, named groups, inline flags such as "(?i)", \\p{...} and POSIX "[[:alpha:]]" classes are not supported, and a pattern cannot span a line break. The pattern must contain at least 3 consecutive literal characters that every match will include — write "error \\d+" rather than "\\w+ \\d+". Escape any metacharacter you mean literally. Matching is case-insensitive until the pattern contains an uppercase letter, which makes it case-sensitive.',
+    'A regular expression matched against each line, 3-512 characters. Supports "." "*" "+" "?" "{n,m}" and their lazy forms, character classes such as "[a-z]" and "[^0-9]", the classes \\d \\w \\s and \\D \\W \\S, alternation "|", groups "(...)" and "(?:...)", the anchors "^" and "$", and the word boundary \\b. Lookahead, lookbehind, backreferences, named groups, inline flags such as "(?i)", \\p{...} and POSIX "[[:alpha:]]" classes are not supported, and a pattern cannot span a line break. The pattern must contain at least 3 consecutive literal characters that every match will include — write "error \\d+" rather than "\\w+ \\d+". Escape any metacharacter you mean literally. Matching is case-insensitive until the pattern contains an uppercase letter you are searching for; uppercase inside an escape or a character class, such as \\D or [A-Z], does not make it case-sensitive.',
   exact:
     'The exact text to find, 3-512 characters. It is matched verbatim: ".", "*", "(" and every other regular-expression metacharacter is searched for as itself, so nothing needs escaping. Matching is case-insensitive until the text contains an uppercase letter, which makes it case-sensitive.',
 }