Text Module

Runtime modules are the built-in capabilities you call from automations on the foundation, and the text module is one of them. It provides pure-JS text processing utilities, with no external dependencies.

parseUrl

Generic URL parser. Extracts standard URL parts (domain, path, query) plus Prisme.ai-specific fields (workspaceId, file id/filename).

- run:
    module: text
    function: parseUrl
    parameters:
      url: "{{uploaded_file.url}}"
    output: parsed
# parsed.domain      → "api.prisme.ai"
# parsed.path        → "/v2/files/ws123/abc.report.pdf"
# parsed.id          → "abc"
# parsed.filename    → "report.pdf"
# parsed.ext          → "pdf"
# parsed.workspaceId → "ws123"
# parsed.mimetype    → "application/pdf"
# parsed.query       → { "token": "xyz" }

Parameter	Type	Required	Default	Description
`url`	string	yes		Any URL (or raw string)

Returns an object with the following fields:

Field	Type	Description
`domain`	string	Hostname (e.g. `api.prisme.ai`). Empty for non-URLs.
`path`	string	Full pathname (e.g. `/v2/files/ws123/abc.report.pdf`).
`id`	string	From the last path segment: everything before the first dot, only when 2+ dots are present. Empty otherwise.
`filename`	string	From the last path segment: everything after the first dot. If no dot, equals the full segment.
`ext`	string	Lowercase file extension from the filename (e.g. `pdf`, `xlsx`). Empty if none.
`workspaceId`	string	Extracted from `/files/{wsId}/…` or `/workspaces/{wsId}/…`. Empty if not found.
`mimetype`	string	MIME type inferred from the file extension.
`query`	object	Query string parameters as key-value pairs.

How `id` / `filename` splitting works

The last path segment is parsed based on the number of dots:

2+ dots ({id}.{name}.{ext}): id is everything before the first dot, filename is the rest.
1 dot ({name}.{ext}): the whole segment is the filename, no id.
0 dots: the whole segment is the filename, no id.

Last segment	`id`	`filename`
`abc123.report.pdf`	`abc123`	`report.pdf`
`doc.pdf`	(empty)	`doc.pdf`
`README`	(empty)	`README`

Examples

Extract a file ID from a native upload URL:

- run:
    module: text
    function: parseUrl
    parameters:
      url: "{{file_part.url}}"
    output: _parsed
- set:
    name: file_id
    value: "{{_parsed.id}}"

Extract workspace ID from any Prisme.ai URL:

- run:
    module: text
    function: parseUrl
    parameters:
      url: "{{webhook_url}}"
    output: _parsed
- set:
    name: ws_id
    value: "{{_parsed.workspaceId}}"

splitText

Split text into chunks using a recursive character splitting strategy. The splitter tries separators in order, splits on the first one found, merges small pieces back up to chunkSize, maintains chunkOverlap between consecutive chunks, and recurses with finer separators for pieces still too large.

- run:
    module: text
    function: splitText
    parameters:
      content: "{{document.text}}"
      chunkSize: 1000
      chunkOverlap: 200
    output: chunks

Parameter	Type	Required	Default	Description
`content`	string \| string[]	yes		Text or array of texts to split
`chunkSize`	number	yes		Maximum size of each chunk (in characters)
`chunkOverlap`	number	yes		Number of overlapping characters between consecutive chunks
`separators`	string[]	no	`["\n\n", "\n", " ", ""]`	Ordered list of separators to try, from coarsest to finest
`keepSeparator`	boolean \| `"start"` \| `"end"`	no	`false`	Attach the separator to the chunk. `true` or `"end"` appends it to the preceding chunk, `"start"` prepends it to the following chunk. Only visible with non-whitespace separators (whitespace is trimmed).

Returns an array of { content, size } objects:

[
  { "content": "First chunk text...", "size": 253 },
  { "content": "Second chunk text...", "size": 241 }
]

Split with custom separators (e.g. Markdown headings)

- run:
    module: text
    function: splitText
    parameters:
      content: "{{document.text}}"
      chunkSize: 1500
      chunkOverlap: 100
      separators:
        - "\n## "
        - "\n### "
        - "\n\n"
        - "\n"
        - " "
        - ""
      keepSeparator: start
    output: chunks

Iterate over chunks

- run:
    module: text
    function: splitText
    parameters:
      content: "{{document.text}}"
      chunkSize: 500
      chunkOverlap: 50
    output: chunks
- repeat:
    on: "{{chunks}}"
    do:
      - emit:
          event: chunk-ready
          payload:
            text: "{{item.content}}"
            size: "{{item.size}}"

search

grep-like line search over a text content. Returns the matching lines with their 1-based line numbers, so an automation can act on positions without re-parsing the text.

- run:
    module: text
    function: search
    parameters:
      content: "{{document.text}}"
      pattern: "ERROR|WARN"
      ignoreCase: true
      context: 1
    output: hits
# hits.count             → number of matching lines
# hits.matches[0].line   → 1-based line number
# hits.matches[0].text   → the line (or matched substring in onlyMatching mode)
# hits.matches[0].context → true for context-only lines

Parameter	Type	Required	Default	Description
content	string	yes		Text to search.
pattern	string	yes		JS regular expression, or a literal string when `fixed` is true.
fixed	boolean	no	false	Match `pattern` literally (grep -F).
ignoreCase	boolean	no	false	Case-insensitive match (grep -i).
invert	boolean	no	false	Return the lines that do NOT match (grep -v).
context	number	no	0	Context lines before and after each match (grep -C).
before / after	number	no		Context lines before / after only (grep -B / -A).
onlyMatching	boolean	no	false	Return only the matched substrings (grep -o).
maxCount	number	no		Stop after this many matching lines (grep -m).

Returns { matches: [{ line, text, context? }], count } where count is the number of matching lines (context lines excluded).

substitute

sed-like regex substitution. Use this instead of the replace() expression helper when you need a regular expression (the expression helper is literal-only). Returns the new content and the number of replacements made, so you can detect no-ops.

- run:
    module: text
    function: substitute
    parameters:
      content: "{{document.text}}"
      pattern: "(\\d{4})-(\\d{2})-(\\d{2})"
      replacement: "$3/$2/$1"
    output: result
# result.content → text with dates reformatted
# result.count   → number of replacements

Parameter	Type	Required	Default	Description
content	string	yes		Text to transform.
pattern	string	yes		JS regular expression, or a literal string when `fixed` is true.
replacement	string	yes		Replacement, with `$1`..`$n` / `$<name>` / `$&` / `$$` backreferences.
fixed	boolean	no	false	Match `pattern` literally.
ignoreCase	boolean	no	false	Case-insensitive match.
all	boolean	no	true	Replace every occurrence; set false for the first only.
lineRange	[number, number]	no		Restrict to lines in the inclusive 1-based range (sed addresses).

Returns { content, count }.

diff

Produces a unified diff between two texts, the complement of applyPatch. Feed the result to applyPatch to reapply the change: applyPatch(a, diff(a, b).patch) yields b.

- run:
    module: text
    function: diff
    parameters:
      a: "{{before}}"
      b: "{{after}}"
    output: d
# d.patch     → unified diff text (empty when a === b)
# d.changed   → boolean
# d.additions → lines added
# d.deletions → lines removed

Parameter	Type	Required	Default	Description
a	string	yes		Original text.
b	string	yes		Modified text.
context	number	no	3	Context lines around each change.
labelA / labelB	string	no	a / b	Labels for the `---` / `+++` header.
noHeader	boolean	no	false	Emit only `@@` hunks, without the file header.

Returns { patch, changed, additions, deletions }.

applyPatch

Applies a unified diff to a text content. Designed for LLM-generated patches: hunks are located by matching their context lines, not by trusting the @@ line numbers (models are unreliable at line arithmetic), so a patch still applies even when its line numbers are off.

- run:
    module: text
    function: applyPatch
    parameters:
      content: "{{document.text}}"
      patch: "{{generated_diff}}"
    output: r
# r.content      → patched text
# r.hunksApplied → number of hunks applied
# r.hunksFailed  → [{ index, reason, context }] for hunks that did not match

Parameter	Type	Required	Default	Description
content	string	yes		Text to patch.
patch	string	yes		Unified diff (as produced by `diff` or by a model).
fuzz	number	no	1	Whitespace tolerance when matching context: 0 exact, 1 ignore trailing whitespace, 2 ignore leading + trailing.
atomic	boolean	no	false	If any hunk fails, return the original content untouched.

Returns { content, hunksTotal, hunksApplied, hunksFailed }. A hunk that fails never corrupts the content, its reason is actionable so a model can regenerate just that hunk.

encodeUriComponent

Percent-encodes a single URI component, exactly like JavaScript’s encodeURIComponent. URLSearchParams(...).asString already encodes, but only as key=value pairs and with + for spaces. A lone path segment has no other native way through — a namespaced project path such as group/sub/repo that must travel as group%2Fsub%2Frepo, for instance.

- run:
    module: text
    function: encodeUriComponent
    parameters:
      value: "{{project.path}}"
    output: encoded
# encoded → "group%2Fsub%2Frepo"

Parameter	Type	Required	Default	Description
value	string	yes		Value to encode. Non-strings are coerced; `null`/`undefined` yield `""`.

Returns the encoded string. Everything outside A-Z a-z 0-9 - _ . ! ~ * ' ( ) is escaped, and a space becomes %20, not +.

removeDiacritics

Strips diacritical marks from text, leaving the base letters. Case is preserved, and text with nothing to fold comes back unchanged.

- run:
    module: text
    function: removeDiacritics
    parameters:
      text: "{{file.name}}"
    output: folded
# "Éléphant à Nîmes" → "Elephant a Nimes"

Parameter	Type	Required	Default	Description
text	string	yes		Text to fold. Non-strings are coerced; `null`/`undefined` yield `""`.
compatibility	boolean	no	false	Also apply compatibility decomposition (NFKD), which folds ligatures and presentation forms: `ﬁ` → `fi`, `²` → `2`. Off by default so removing an accent stays the only visible effect.

Two passes, because neither alone suffices. Unicode decomposition splits a precomposed letter into base + combining mark and every non-spacing mark is dropped, which covers Latin, Greek and Cyrillic without enumerating anything. A small table then handles the letters that have no decomposition — a stroke or a bar is part of the glyph, not a combining mark, so ø, đ, ł, ħ survive the first pass untouched; ligatures that are letters in their own right (æ, œ, ß) are expanded here too. A typical use is normalising a filename before upload: macOS stores filenames in NFD, and services that store an upload under one normalisation but reference it under another will 404 on accented names.

Overview

Chat

Agent Creator

Knowledges

Collections

Builder

Governe

Engage

Insights

parseUrl

How `id` / `filename` splitting works

Examples

splitText

Split with custom separators (e.g. Markdown headings)

Iterate over chunks

search

substitute

diff

applyPatch

encodeUriComponent

removeDiacritics

​parseUrl

​How id / filename splitting works

​Examples

​splitText

​Split with custom separators (e.g. Markdown headings)

​Iterate over chunks

​search

​substitute

​diff

​applyPatch

​encodeUriComponent

​removeDiacritics

parseUrl

How `id` / `filename` splitting works

Examples

splitText

Split with custom separators (e.g. Markdown headings)

Iterate over chunks

search

substitute

diff

applyPatch

encodeUriComponent

removeDiacritics