@nghyane/arcane 0.1.0

package/src/prompts/tools/calculator.md

@@ -0,0 +1,12 @@
+# Calculator
+
+Basic calculations.
+
+<instruction>
+- Supports +, -, *, /, %, ** and parentheses
+- Supports decimal, hex (0x), binary (0b), and octal (0o) literals
+</instruction>
+
+<output>
+Returns each calculation result with its prefix and suffix applied.
+</output>

package/src/prompts/tools/explore.md

@@ -0,0 +1,29 @@
+# Explore
+
+Intelligently search the codebase using a specialized read-only subagent. Use for complex, multi-step search tasks where you need to find code based on functionality or concepts rather than exact matches.
+
+## When to use
+- Locate code by behavior or concept (not exact string match)
+- Chain multiple searches to correlate areas of the codebase
+- Answer questions like "Where is JWT authentication implemented?"
+- Understand architecture or data flow across files
+- Map dependencies between modules
+
+## When NOT to use
+- When you know the exact file path (use Read directly)
+- When looking for a specific string/symbol (use Grep or Find)
+- When you need to create/modify files (this is read-only)
+
+## Parameters
+
+### `query` (required)
+
+The search query describing what you need to find. Be specific — include technical terms, file types, expected code patterns, or API names. State explicit success criteria.
+
+## Output
+
+Returns structured JSON with:
+- `files`: files examined with exact line ranges
+- `code`: critical types/interfaces/functions extracted verbatim
+- `architecture`: brief explanation of how pieces connect
+- `start_here`: recommended entry point for you to continue from

package/src/prompts/tools/fetch.md

@@ -0,0 +1,16 @@
+# Fetch
+
+Retrieves content from a URL and returns it in a clean, readable format.
+
+<instruction>
+- Extract information from web pages (documentation, articles, API references)
+- Analyze GitHub issues, PRs, or repository content
+- Retrieve from Stack Overflow, Wikipedia, Reddit, NPM, arXiv, technical blogs
+- Access RSS/Atom feeds or JSON endpoints
+- Read PDF or DOCX files hosted at a URL
+- Use `raw: true` for untouched HTML or debugging
+</instruction>
+
+<output>
+Returns processed, readable content extracted from the URL. HTML is transformed to remove navigation, ads, and boilerplate. PDF and DOCX files are converted to text. JSON endpoints return formatted JSON. With `raw: true`, returns untransformed HTML.
+</output>

package/src/prompts/tools/find.md

@@ -0,0 +1,18 @@
+# Find
+
+Fast file pattern matching that works with any codebase size.
+
+<instruction>
+- Pattern includes the search path: `src/**/*.ts`, `lib/*.json`, `**/*.md`
+- Simple patterns like `*.ts` automatically search recursively from cwd
+- Includes hidden files by default (use `hidden: false` to exclude)
+- Speculatively perform multiple searches in parallel when potentially useful
+</instruction>
+
+<output>
+Matching file paths sorted by modification time (most recent first). Results truncated at 1000 entries or 50KB (configurable via `limit`).
+</output>
+
+<avoid>
+Open-ended searches requiring multiple rounds of globbing and grepping — use Task tool instead.
+</avoid>

package/src/prompts/tools/gemini-image.md

@@ -0,0 +1,23 @@
+# Gemini Image
+
+Generate or edit images using Gemini image models.
+
+<instruction>
+Provide structured parameters for best results. Tool assembles into optimized prompt.
+
+When using multiple `input_images`, describe each image's role in `subject` or `scene` field:
+- "Use Image 1 for the character's face and outfit, Image 2 for the pose, Image 3 for the background environment"
+- "Match the color palette from Image 1, apply the lighting style from Image 2"
+</instruction>
+
+<output>
+Returns generated image saved to disk. Response includes file path where image was written.
+</output>
+
+<caution>
+- For photoreal: add "ultra-detailed, realistic, natural skin texture" to style
+- For posters/cards: use 9:16 aspect ratio with negative space for text placement
+- For iteration: use `changes` for targeted adjustments rather than regenerating from scratch
+- For text: add "sharp, legible, correctly spelled" for important text; keep text short
+- For diagrams: include "scientifically accurate" in style and provide facts explicitly
+</caution>

package/src/prompts/tools/grep.md

@@ -0,0 +1,28 @@
+# Grep
+
+Powerful search tool built on ripgrep.
+
+<instruction>
+- Supports full regex syntax (e.g., `log.*Error`, `function\\s+\\w+`)
+- Filter files with `glob` (e.g., `*.js`, `**/*.tsx`) or `type` (e.g., `js`, `py`, `rust`)
+- Pattern syntax uses ripgrep—literal braces need escaping (`interface\\{\\}` to find `interface{}` in Go)
+- For cross-line patterns like `struct \\{[\\s\\S]*?field`, set `multiline: true` if needed
+- If the pattern contains a literal `\n`, multiline defaults to true
+</instruction>
+
+<output>
+- Results are always content mode.
+{{#if IS_HASHLINE_MODE}}
+- Text output is CID prefixed: `LINE#ID:content`
+{{else}}
+{{#if IS_LINE_NUMBER_MODE}}
+- Text output is line-number-prefixed
+{{/if}}
+{{/if}}
+</output>
+
+<critical>
+- ALWAYS use Grep when searching for content.
+- NEVER invoke `grep` or `rg` via Bash.
+- If the search is open-ended, requiring multiple rounds, use Task tool with explore subagent instead
+</critical>

package/src/prompts/tools/hashline.md

@@ -0,0 +1,232 @@
+# Edit
+
+Apply precise file edits using `LINE#ID` tags, anchoring to the file content.
+
+<workflow>
+1. `read` the target range to capture current `LINE#ID` tags.
+2. Pick the smallest operation per change site (line/range/insert/content-replace).
+3. Direction-lock every edit: exact current text → intended text.
+4. Submit one `edit` call per file containing all operations.
+5. If another edit is needed in that file, re-read first (hashes changed).
+6. Output tool calls only; no prose.
+</workflow>
+
+<operations>
+- **Single line replace/delete**
+  - `{ op: "set", tag: "N#ID", content: […] }`
+  - `content: null` deletes the line; `content: [""]` keeps a blank line.
+- **Range replace/delete**
+  - `{ op: "replace", first: "N#ID", last: "N#ID", content: […] }`
+  - Use for swaps, block rewrites, or deleting a full span (`content: null`).
+- **Insert** (new content)
+  - `{ op: "prepend", before: "N#ID", content: […] }` or `{ op: "prepend", content: […] }` (no `before` = insert at beginning of file)
+  - `{ op: "append", after: "N#ID", content: […] }` or `{ op: "append", content: […] }` (no `after` = insert at end of file)
+  - `{ op: "insert", after: "N#ID", before: "N#ID", content: […] }` (between adjacent anchors; safest for blocks)
+{{#if allowReplaceText}}
+- **Content replace**
+  - `{ op: "replaceText", old_text: "…", new_text: "…", all?: boolean }`
+{{/if}}
+- **File-level controls**
+  - `{ delete: true, edits: [] }` deletes the file (cannot be combined with `rename`).
+  - `{ rename: "new/path.ts", edits: […] }` writes result to new path and removes old path.
+**Atomicity:** all ops validate against the same pre-edit file snapshot; refs are interpreted against last `read`; applicator applies bottom-up.
+</operations>
+
+<rules>
+1. **Minimize scope:** one logical mutation site per operation.
+2. **Preserve formatting:** keep indentation, punctuation, line breaks, trailing commas, brace style.
+3. **Prefer insertion over neighbor rewrites:** anchor on structural boundaries (`}`, `]`, `},`) not interior property lines.
+4. **No no-ops:** replacement content must differ from current content.
+5. **Touch only requested code:** avoid incidental edits.
+6. **Use exact current tokens:** never rewrite approximately; mutate the token that exists now.
+7. **For swaps/moves:** prefer one range operation over multiple single-line operations.
+</rules>
+
+<op_choice>
+- One wrong line → `set`
+- Adjacent block changed → `insert`
+- Missing line/block → insert with `append`/`prepend`
+</op_choice>
+
+<tag_choice>
+- Copy tags exactly from the prefix of the `read` or error output.
+- Never guess tags.
+- For inserts, prefer `insert` > `append`/`prepend` when both boundaries are known.
+- Re-read after each successful edit call before issuing another on same file.
+</tag_choice>
+
+<recovery>
+**Tag mismatch (`>>>`)**
+- Retry with the updated tags shown in error output.
+- Re-read only if required tags are missing from error snippet.
+- If mismatch repeats, stop and re-read the exact block.
+</recovery>
+
+<example name="fix a value or type">
+```ts
+{{hlinefull 23 "  const timeout: number = 5000;"}}
+```
+```
+op: "set"
+tag: "{{hlineref 23 "  const timeout: number = 5000;"}}"
+content: ["  const timeout: number = 30_000;"]
+```
+</example>
+
+<example name="remove a line entirely">
+```ts
+{{hlinefull 7 "// @ts-ignore"}}
+{{hlinefull 8 "const data = fetchSync(url);"}}
+```
+```
+op: "set"
+tag: "{{hlineref 7 "// @ts-ignore"}}"
+content: null
+```
+</example>
+
+<example name="clear content but keep the line break">
+```ts
+{{hlinefull 14 "  placeholder: \"DO NOT SHIP\","}}
+```
+```
+op: "set"
+tag: "{{hlineref 14 "  placeholder: \"DO NOT SHIP\","}}"
+content: [""]
+```
+</example>
+
+<example name="rewrite a block of logic">
+```ts
+{{hlinefull 60 "    } catch (err) {"}}
+{{hlinefull 61 "      console.error(err);"}}
+{{hlinefull 62 "      return null;"}}
+{{hlinefull 63 "    }"}}
+```
+```
+op: "replace"
+first: "{{hlineref 60 "    } catch (err) {"}}"
+last: "{{hlineref 63 "    }"}}"
+content: ["    } catch (err) {", "      if (isEnoent(err)) return null;", "      throw err;", "    }"]
+```
+</example>
+
+<example name="remove a full block">
+```ts
+{{hlinefull 80 "  // TODO: remove after migration"}}
+{{hlinefull 81 "  if (legacy) {"}}
+{{hlinefull 82 "    legacyHandler(req);"}}
+{{hlinefull 83 "  }"}}
+```
+```
+op: "replace"
+first: "{{hlineref 80 "  // TODO: remove after migration"}}"
+last: "{{hlineref 83 "  }"}}"
+content: null
+```
+</example>
+
+<example name="add an import above the first import">
+```ts
+{{hlinefull 1 "import * as fs from \"node:fs/promises\";"}}
+{{hlinefull 2 "import * as path from \"node:path\";"}}
+```
+```
+op: "prepend"
+before: "{{hlineref 1 "import * as fs from \"node:fs/promises\";"}}"
+content: ["import * as os from \"node:os\";"]
+```
+Use `before` for anchored insertion before a specific line. Omit `before` to prepend at BOF.
+</example>
+
+<example name="append at end of file">
+```ts
+{{hlinefull 260 "export { serialize, deserialize };"}}
+```
+```
+op: "append"
+after: "{{hlineref 260 "export { serialize, deserialize };"}}"
+content: ["export { validate };"]
+```
+Use `after` for anchored insertion after a specific line. Omit `after` to append at EOF.
+</example>
+
+<example name="add an entry between known siblings">
+```ts
+{{hlinefull 44 "  \"build\": \"bun run compile\","}}
+{{hlinefull 45 "  \"test\": \"bun test\""}}
+```
+```
+op: "insert"
+after: "{{hlineref 44 "  \"build\": \"bun run compile\","}}"
+before: "{{hlineref 45 "  \"test\": \"bun test\""}}"
+content: ["  \"lint\": \"biome check\","]
+```
+Dual anchors pin the insert to exactly one gap, preventing drift from edits elsewhere in the file. **Always prefer dual anchors when both boundaries are content lines.**
+</example>
+
+<example name="insert a function before another function">
+```ts
+{{hlinefull 100 "  return buf.toString(\"hex\");"}}
+{{hlinefull 101 "}"}}
+{{hlinefull 102 ""}}
+{{hlinefull 103 "export function serialize(data: unknown): string {"}}
+```
+```
+op: "insert"
+before: "{{hlineref 103 "export function serialize(data: unknown): string {"}}"
+content: ["function validate(data: unknown): boolean {", "  return data != null && typeof data === \"object\";", "}", ""]
+```
+The trailing `""` in `content` preserves the blank-line separator. **Anchor to the structural line (`export function ...`), not the blank line above it** — blank lines are ambiguous and may be added or removed by other edits.
+</example>
+
+{{#if allowReplaceText}}
+<example name="content replace (rare)">
+```
+op: "replaceText"
+old_text: "x = 42"
+new_text: "x = 99"
+```
+
+Use only when line anchors aren't available. `old_text` must match exactly one location in the file (or set `"all": true` for all occurrences).
+</example>
+{{/if}}
+
+<example name="file delete">
+```
+path: "src/deprecated/legacy.ts"
+delete: true
+```
+</example>
+
+<example name="file rename with edits">
+```
+path: "src/utils.ts"
+rename: "src/helpers/utils.ts"
+edits: […]
+```
+</example>
+
+<example name="anti-pattern: anchoring to whitespace">
+Bad — tags to a blank line; fragile if blank lines shift:
+```
+after: "{{hlineref 102 ""}}"
+content: ["function validate() {", …, "}"]
+```
+
+Good — anchors to the structural target:
+
+```
+before: "{{hlineref 103 "export function serialize(data: unknown): string {"}}"
+content: ["function validate() {", …, "}"]
+```
+</example>
+
+<critical>
+Ensure:
+- Payload shape is `{ "path": string, "edits": [operation, …], "delete"?: boolean, "rename"?: string }`
+- Every edit matches exactly one variant
+- Every tag has been copied EXACTLY from a tool result as `N#ID`
+- Scope is minimal and formatting is preserved except targeted token changes
+</critical>
+**Final reminder:** tags are immutable references to the last read snapshot. Re-read when state changes, then edit.

package/src/prompts/tools/librarian.md

@@ -0,0 +1,24 @@
+# Librarian
+
+Explore and understand codebases across repositories using a specialized agent.
+
+## When to use
+- Understanding complex codebases and architecture
+- Exploring relationships between repositories
+- Finding implementations across codebases
+- Understanding code evolution and commit history
+- Getting comprehensive explanations of features
+- Browsing remote GitHub repositories
+
+## When NOT to use
+- Simple local file reading (use Read)
+- Local codebase searches (use Explore or Grep)
+- Code modifications (use other tools)
+
+## Parameters
+
+### `query` (required)
+Your question about the codebase. Be specific about repositories and what you want to understand.
+
+### `context` (optional)
+Background about what you're trying to achieve.

package/src/prompts/tools/lsp.md

@@ -0,0 +1,28 @@
+# LSP
+
+Interact with Language Server Protocol servers for code intelligence.
+
+<operations>
+- `definition`: Go to symbol definition
+- `references`: Find all references to symbol
+- `hover`: Get type info and documentation
+- `symbols`: List symbols in file, or search workspace (with query, no file)
+- `rename`: Rename symbol across codebase
+- `diagnostics`: Get errors/warnings for file, or check entire project (no file)
+- `reload`: Restart the language server
+</operations>
+
+<output>
+- `definition`: File path and position of definition
+- `references`: List of locations (file + position) where symbol used
+- `hover`: Type signature and documentation text
+- `symbols`: List of symbol names, kinds, locations
+- `rename`: Confirmation of changes made across files
+- `diagnostics`: List of errors/warnings with file, line, severity, message
+- `reload`: Confirmation of server restart
+</output>
+
+<caution>
+- Requires running LSP server for target language
+- Some operations require file to be saved to disk
+</caution>

package/src/prompts/tools/oracle.md

@@ -0,0 +1,26 @@
+# Oracle
+
+Consult a reasoning advisor for reviews, architecture, debugging, and planning.
+
+## When to use
+- Code reviews and architecture feedback
+- Finding bugs across multiple files
+- Planning complex implementations or refactoring
+- Analyzing code quality
+- Complex technical questions requiring deep reasoning
+
+## When NOT to use
+- Simple file reading or searching (use Read/Grep)
+- Codebase exploration (use Explore)
+- Basic code modifications (do it yourself or use Task)
+
+## Parameters
+
+### `task` (required)
+Specific question or task. Be precise about what guidance you need.
+
+### `context` (optional)
+Background: current situation, what you've tried, constraints.
+
+### `files` (optional)
+File paths to examine. These are read and attached to the oracle's input.

package/src/prompts/tools/patch.md

@@ -0,0 +1,74 @@
+# Edit (Patch)
+
+Patch operations on file given diff. Primary tool for existing-file edits.
+
+<instruction>
+**Hunk Headers:**
+- `@@` — bare header when context lines unique
+- `@@ $ANCHOR` — anchor copied verbatim from file (full line or unique substring)
+**Anchor Selection:**
+1. Otherwise choose highly specific anchor copied from file:
+   - full function signature
+   - class declaration
+   - unique string literal/error message
+   - config key with uncommon name
+2. On "Found multiple matches": add context lines, use multiple hunks with separate anchors, or use longer anchor substring
+**Context Lines:**
+Use enough ` `-prefixed lines to make match unique (usually 2–8)
+When editing structured blocks (nested braces, tags, indented regions), include opening and closing lines so edit stays inside block
+</instruction>
+
+<parameters>
+```ts
+type T =
+   // Diff is one or more hunks in the same file.
+   // - Each hunk begins with "@@" (anchor optional).
+   // - Each hunk body only has lines starting with ' ' | '+' | '-'.
+   // - Each hunk includes at least one change (+ or -).
+   | { path: string, op: "update", diff: string }
+   // Diff is full file content, no prefixes.
+   | { path: string, op: "create", diff: string }
+   // No diff for delete.
+   | { path: string, op: "delete" }
+   // New path for update+move.
+   | { path: string, op: "update", rename: string, diff: string }
+```
+</parameters>
+
+<output>
+Returns success/failure; on failure, error message indicates:
+- "Found multiple matches" — anchor/context not unique enough
+- "No match found" — context lines don't exist in file (wrong content or stale read)
+- Syntax errors in diff format
+</output>
+
+<critical>
+- Always read target file before editing
+- Copy anchors and context lines verbatim (including whitespace)
+- Never use anchors as comments (no line numbers, location labels, placeholders like `@@ @@`)
+- Do not place new lines outside intended block
+- If edit fails or breaks structure, re-read file and produce new patch from current content—do not retry same diff
+- **NEVER** use edit to fix indentation, whitespace, or reformat code. Formatting is a single command run once at the end (`bun fmt`, `cargo fmt`, `prettier --write`, etc.)—not N individual edits. If you see inconsistent indentation after an edit, leave it; the formatter will fix all of it in one pass.
+</critical>
+
+<example name="create">
+edit {"path":"hello.txt","op":"create","diff":"Hello\n"}
+</example>
+
+<example name="update">
+edit {"path":"src/app.py","op":"update","diff":"@@ def greet():\n def greet():\n-print('Hi')\n+print('Hello')\n"}
+</example>
+
+<example name="rename">
+edit {"path":"src/app.py","op":"update","rename":"src/main.py","diff":"@@\n ...\n"}
+</example>
+
+<example name="delete">
+edit {"path":"obsolete.txt","op":"delete"}
+</example>
+
+<avoid>
+- Generic anchors: `import`, `export`, `describe`, `function`, `const`
+- Repeating same addition in multiple hunks (duplicate blocks)
+- Full-file overwrites for minor changes (acceptable for major restructures or short files)
+</avoid>

package/src/prompts/tools/python.md

@@ -0,0 +1,66 @@
+# Python
+
+Runs Python cells sequentially in persistent IPython kernel.
+
+<instruction>
+Kernel persists across calls and cells; **imports, variables, and functions survive—use this.**
+**Work incrementally:**
+- One logical step per cell (imports, define function, test it, use it)
+- Pass multiple small cells in one call
+- Define small functions you can reuse and debug individually
+- Put explanations in assistant message or cell title, **not** in code
+**When something fails:**
+- Errors tell you which cell failed (e.g., "Cell 3 failed")
+- Resubmit only fixed cell (or fixed cell + remaining cells)
+</instruction>
+
+<prelude>
+All helpers auto-print results and return values for chaining.
+
+{{#if categories.length}}
+{{#each categories}}
+### {{name}}
+
+```
+{{#each functions}}
+{{name}}{{signature}}
+    {{docstring}}
+{{/each}}
+```
+{{/each}}
+{{else}}
+(Documentation unavailable — Python kernel failed to start)
+{{/if}}
+</prelude>
+
+<output>
+Streams in real time, truncated after 100KB; if truncated, full output stored under $ARTIFACTS and referenced as `artifact://<id>` in metadata.
+
+User sees output like Jupyter notebook; rich displays render fully:
+- `display(JSON(data))` → interactive JSON tree
+- `display(HTML(...))` → rendered HTML
+- `display(Markdown(...))` → formatted markdown
+- `plt.show()` → inline figures
+  **You will see object repr** (e.g., `<IPython.core.display.JSON object>`). Trust `display()`; do not assume user sees only repr.
+</output>
+
+<caution>
+- Per-call mode uses fresh kernel each call
+- Use `reset: true` to clear state when session mode active
+</caution>
+
+<critical>
+- Use `run()` for shell commands; never raw `subprocess`
+</critical>
+
+<example name="good">
+```python
+# Multiple small cells
+cells: [
+    {"title": "imports", "code": "import json\nfrom pathlib import Path"},
+    {"title": "parse helper", "code": "def parse_config(path):\n    return json.loads(Path(path).read_text())"},
+    {"title": "test helper", "code": "parse_config('config.json')"},
+    {"title": "use helper", "code": "configs = [parse_config(p) for p in Path('.').glob('*.json')]"}
+]
+```
+</example>

package/src/prompts/tools/read.md

@@ -0,0 +1,36 @@
+# Read
+
+Reads files from local filesystem or internal URLs.
+
+<instruction>
+- Reads up to {{DEFAULT_MAX_LINES}} lines default
+- Use `offset` and `limit` for large files
+{{#if IS_HASHLINE_MODE}}
+- Text output is CID prefixed: `LINE#ID:content`
+{{else}}
+{{#if IS_LINE_NUMBER_MODE}}
+- Text output is line-number-prefixed
+{{/if}}
+{{/if}}
+- Supports images (PNG, JPG) and PDFs
+- For directories, returns formatted listing with modification times
+- Parallelize reads when exploring related files
+- Supports internal URLs:
+  - `skill://<name>` - read SKILL.md for a skill
+  - `skill://<name>/<path>` - read relative path within skill directory
+  - `rule://<name>` - read rule content
+  - `memory://root` - read memory summary (`memory_summary.md`)
+  - `memory://root/<path>` - read relative path within project memory root
+  - `agent://<id>` - read agent output artifact
+  - `agent://<id>/<path>` or `agent://<id>?q=<query>` - extract JSON from agent output
+  - `docs://` - list available pi documentation files
+  - `docs://<file>.md` - read a specific pi documentation file
+</instruction>
+
+<output>
+- Returns file content as text
+- Images: returns visual content for analysis
+- PDFs: returns extracted text
+- Missing files: returns closest filename matches for correction
+- Internal URLs: returns resolved content with pagination support
+</output>

package/src/prompts/tools/replace.md

@@ -0,0 +1,38 @@
+# Edit (Replace)
+
+String replacements in files with fuzzy whitespace matching.
+
+<instruction>
+- Use smallest edit that uniquely identifies change
+- If `old_text` not unique, expand to include more context or use `all: true` to replace all occurrences
+- Fuzzy matching handles minor whitespace/indentation differences automatically
+- Prefer editing existing files over creating new ones
+</instruction>
+
+<output>
+Returns success/failure status. On success, file modified in place with replacement applied. On failure (e.g., `old_text` not found or matches multiple locations without `all: true`), returns error describing issue.
+</output>
+
+<critical>
+- Must read file at least once in conversation before editing. Tool errors if you attempt edit without reading file first.
+</critical>
+
+<bash*alternatives>
+Replace for content-addressed changes—you identify \_what* to change by its text.
+
+For position-addressed or pattern-addressed changes, bash more efficient:
+
+|Operation|Command|
+|---|---|
+|Append to file|`cat >> file <<'EOF'`...`EOF`|
+|Prepend to file|`{ cat - file; } <<'EOF' > tmp && mv tmp file`|
+|Delete lines N-M|`sed -i 'N,Md' file`|
+|Insert after line N|`sed -i 'Na\text' file`|
+|Regex replace|`sd 'pattern' 'replacement' file`|
+|Bulk replace across files|`sd 'pattern' 'replacement' **/*.ts`|
+|Copy lines N-M to another file|`sed -n 'N,Mp' src >> dest`|
+|Move lines N-M to another file|`sed -n 'N,Mp' src >> dest && sed -i 'N,Md' src`|
+
+Use Replace when _content itself_ identifies location.
+Use bash when _position_ or _pattern_ identifies what to change.
+</bash_alternatives>