type: string

text: string

startIndex: number

endIndex: number

children: TreeSitterNode[]

childCount: number

/** Command text with single-quoted content removed (double-quoted content preserved) */

withDoubleQuotes: string

/** Command text with all quoted content removed */

fullyUnquoted: string

/** Like fullyUnquoted but preserves quote characters (', ") */

unquotedKeepQuoteChars: string

/** Whether the command has compound operators (&&, ||, ;) at the top level */

hasCompoundOperators: boolean

/** Whether the command has pipelines */

hasPipeline: boolean

/** Whether the command has subshells */

hasSubshell: boolean

/** Whether the command has command groups ({...}) */

hasCommandGroup: boolean

/** Top-level compound operator types found */

operators: string[]

/** Individual command segments split by compound operators */

segments: string[]

/** Has $() or backtick command substitution (outside quotes that would make it safe) */

hasCommandSubstitution: boolean

/** Has <() or >() process substitution */

hasProcessSubstitution: boolean

/** Has ${...} parameter expansion */

hasParameterExpansion: boolean

/** Has heredoc */

hasHeredoc: boolean

/** Has comment */

hasComment: boolean

quoteContext: QuoteContext

compoundStructure: CompoundStructure

/** Whether actual operator nodes (;, &&, ||) exist — if false, \; is just a word argument */

hasActualOperatorNodes: boolean

dangerousPatterns: DangerousPatterns

raw: Array<[number, number]> // raw_string (single-quoted)

ansiC: Array<[number, number]> // ansi_c_string ($'...')

double: Array<[number, number]> // string (double-quoted)

heredoc: Array<[number, number]> // quoted heredoc_redirect

node: TreeSitterNode,

out: QuoteSpans,

inDouble: boolean,

): void {

switch (node.type) {

case 'raw_string':

out.raw.push([node.startIndex, node.endIndex])

return // literal body, no nested quotes possible

case 'ansi_c_string':

out.ansiC.push([node.startIndex, node.endIndex])

return // literal body

case 'string':

// Only collect the outermost string (matches old per-type walk

// which stops at first match). Recurse regardless — a nested

// $(cmd 'x') inside "..." has a real inner raw_string.

if (!inDouble) out.double.push([node.startIndex, node.endIndex])

for (const child of node.children) {

if (child) collectQuoteSpans(child, out, true)

}

return

case 'heredoc_redirect': {

// Quoted heredocs (<<'EOF', <<"EOF", <<\EOF): literal body.

// Unquoted (<<EOF) expands $()/${} — the body can contain

// $(cmd 'x') whose inner '...' IS a real raw_string node.

// Detection: heredoc_start text starts with '/"/\\

// Matches sync path's extractHeredocs({ quotedOnly: true }).

let isQuoted = false

for (const child of node.children) {

if (child && child.type === 'heredoc_start') {

const first = child.text[0]

isQuoted = first === "'" || first === '"' || first === '\\'

break

}

}

if (isQuoted) {

out.heredoc.push([node.startIndex, node.endIndex])

return // literal body, no nested quote nodes

}

// Unquoted: recurse into heredoc_body → command_substitution →

// inner quote nodes. The original per-type walks did NOT stop at

// heredoc_redirect (not in their type sets), so they recursed here.

break

}

}

for (const child of node.children) {

if (child) collectQuoteSpans(child, out, inDouble)

}

const set = new Set<number>()

for (const [start, end] of spans) {

for (let i = start; i < end; i++) {

set.add(i)

}

}

return set

spans: T[],

): T[] {

return spans.filter(

(s, i) =>

!spans.some(

(other, j) =>

j !== i &&

other[0] <= s[0] &&

other[1] >= s[1] &&

(other[0] < s[0] || other[1] > s[1]),

),

)

if (spans.length === 0) return command

// Drop inner spans that are fully contained in an outer one, then sort by

// start index descending so we can splice without offset shifts.

const sorted = dropContainedSpans(spans).sort((a, b) => b[0] - a[0])

let result = command

for (const [start, end] of sorted) {

result = result.slice(0, start) + result.slice(end)

}

return result

command: string,

spans: Array<[number, number, string, string]>,

): string {

if (spans.length === 0) return command

const sorted = dropContainedSpans(spans).sort((a, b) => b[0] - a[0])

let result = command

for (const [start, end, open, close] of sorted) {

// Replace content but keep the quote delimiters

result = result.slice(0, start) + open + close + result.slice(end)

}

return result

rootNode: unknown,

command: string,

): QuoteContext {

// Single walk collects all quote span types at once.

const spans: QuoteSpans = { raw: [], ansiC: [], double: [], heredoc: [] }

collectQuoteSpans(rootNode as TreeSitterNode, spans, false)

const singleQuoteSpans = spans.raw

const ansiCSpans = spans.ansiC

const doubleQuoteSpans = spans.double

const quotedHeredocSpans = spans.heredoc

const allQuoteSpans = [

...singleQuoteSpans,

...ansiCSpans,

...doubleQuoteSpans,

...quotedHeredocSpans,

]

// Build a set of positions that should be excluded for each output variant.

// For withDoubleQuotes: remove single-quoted spans entirely, plus the

// opening/closing `"` delimiters of double-quoted spans (but keep the

// content between them). This matches the regex extractQuotedContent()

// semantics where `"` toggles quote state but content is still emitted.

const singleQuoteSet = buildPositionSet([

...singleQuoteSpans,

...ansiCSpans,

...quotedHeredocSpans,

])

const doubleQuoteDelimSet = new Set<number>()

for (const [start, end] of doubleQuoteSpans) {

doubleQuoteDelimSet.add(start) // opening "

doubleQuoteDelimSet.add(end - 1) // closing "

}

let withDoubleQuotes = ''

for (let i = 0; i < command.length; i++) {

if (singleQuoteSet.has(i)) continue

if (doubleQuoteDelimSet.has(i)) continue

withDoubleQuotes += command[i]

}

// fullyUnquoted: remove all quoted content

const fullyUnquoted = removeSpans(command, allQuoteSpans)

// unquotedKeepQuoteChars: remove content but keep delimiter chars

const spansWithQuoteChars: Array<[number, number, string, string]> = []

for (const [start, end] of singleQuoteSpans) {

spansWithQuoteChars.push([start, end, "'", "'"])

}

for (const [start, end] of ansiCSpans) {

// ansi_c_string spans include the leading $; preserve it so this

// matches the regex path, which treats $ as unquoted preceding '.

spansWithQuoteChars.push([start, end, "$'", "'"])

}

for (const [start, end] of doubleQuoteSpans) {

spansWithQuoteChars.push([start, end, '"', '"'])

}

for (const [start, end] of quotedHeredocSpans) {

// Heredoc redirect spans have no inline quote delimiters — strip entirely.

spansWithQuoteChars.push([start, end, '', ''])

}

const unquotedKeepQuoteChars = replaceSpansKeepQuotes(

command,

spansWithQuoteChars,

)

return { withDoubleQuotes, fullyUnquoted, unquotedKeepQuoteChars }

rootNode: unknown,

command: string,

): CompoundStructure {

const n = rootNode as TreeSitterNode

const operators: string[] = []

const segments: string[] = []

let hasSubshell = false

let hasCommandGroup = false

let hasPipeline = false

// Walk top-level children of the program node

function walkTopLevel(node: TreeSitterNode): void {

for (const child of node.children) {

if (!child) continue

if (child.type === 'list') {

// list nodes contain && and || operators

for (const listChild of child.children) {

if (!listChild) continue

if (listChild.type === '&&' || listChild.type === '||') {

operators.push(listChild.type)

} else if (

listChild.type === 'list' ||

listChild.type === 'redirected_statement'

) {

// Nested list, or redirected_statement wrapping a list/pipeline —

// recurse so inner operators/pipelines are detected. For

// `cmd1 && cmd2 2>/dev/null && cmd3`, the redirected_statement

// wraps `list(cmd1 && cmd2)` — the inner `&&` would be missed

// without recursion.

walkTopLevel({ ...node, children: [listChild] } as TreeSitterNode)

} else if (listChild.type === 'pipeline') {

hasPipeline = true

segments.push(listChild.text)

} else if (listChild.type === 'subshell') {

hasSubshell = true

segments.push(listChild.text)

} else if (listChild.type === 'compound_statement') {

hasCommandGroup = true

segments.push(listChild.text)

} else {

segments.push(listChild.text)

}

}

} else if (child.type === ';') {

operators.push(';')

} else if (child.type === 'pipeline') {

hasPipeline = true

segments.push(child.text)

} else if (child.type === 'subshell') {

hasSubshell = true

segments.push(child.text)

} else if (child.type === 'compound_statement') {

hasCommandGroup = true

segments.push(child.text)

} else if (

child.type === 'command' ||

child.type === 'declaration_command' ||

child.type === 'variable_assignment'

) {

segments.push(child.text)

} else if (child.type === 'redirected_statement') {

// `cd ~/src && find path 2>/dev/null` — tree-sitter wraps the ENTIRE

// compound in a redirected_statement: program → redirected_statement →

// (list → cmd1, &&, cmd2) + file_redirect. Same for `cmd1 | cmd2 > out`

// (wraps pipeline) and `(cmd) > out` (wraps subshell). Recurse to

// detect the inner structure; skip file_redirect children (redirects

// don't affect compound/pipeline classification).

let foundInner = false

for (const inner of child.children) {

if (!inner || inner.type === 'file_redirect') continue

foundInner = true

walkTopLevel({ ...child, children: [inner] } as TreeSitterNode)

}

if (!foundInner) {

// Standalone redirect with no body (shouldn't happen, but fail-safe)

segments.push(child.text)

}

} else if (child.type === 'negated_command') {

// `! cmd` — recurse into the inner command so its structure is

// classified (pipeline/subshell/etc.), but also record the full

// negated text as a segment so segments.length stays meaningful.

segments.push(child.text)

walkTopLevel(child)

} else if (

child.type === 'if_statement' ||

child.type === 'while_statement' ||

child.type === 'for_statement' ||

child.type === 'case_statement' ||

child.type === 'function_definition'

) {

// Control-flow constructs: the construct itself is one segment,

// but recurse so inner pipelines/subshells/operators are detected.

segments.push(child.text)

walkTopLevel(child)

}

}

}

walkTopLevel(n)

// If no segments found, the whole command is one segment

if (segments.length === 0) {

segments.push(command)

}

return {

hasCompoundOperators: operators.length > 0,

hasPipeline,

hasSubshell,

hasCommandGroup,

operators,

segments,

}

const n = rootNode as TreeSitterNode

function walk(node: TreeSitterNode): boolean {

// Check for operator types that indicate compound commands

if (node.type === ';' || node.type === '&&' || node.type === '||') {

// Verify this is a child of a list or program, not inside a command

return true

}

if (node.type === 'list') {

// A list node means there are compound operators

return true

}

for (const child of node.children) {

if (child && walk(child)) return true

}

return false

}

return walk(n)

const n = rootNode as TreeSitterNode

let hasCommandSubstitution = false

let hasProcessSubstitution = false

let hasParameterExpansion = false

let hasHeredoc = false

let hasComment = false

function walk(node: TreeSitterNode): void {

switch (node.type) {

case 'command_substitution':

hasCommandSubstitution = true

break

case 'process_substitution':

hasProcessSubstitution = true

break

case 'expansion':

hasParameterExpansion = true

break

case 'heredoc_redirect':

hasHeredoc = true

break

case 'comment':

hasComment = true

break

}

for (const child of node.children) {

if (child) walk(child)

}

}

walk(n)

return {

hasCommandSubstitution,

hasProcessSubstitution,

hasParameterExpansion,

hasHeredoc,

hasComment,

}

rootNode: unknown,

command: string,

): TreeSitterAnalysis {

return {

quoteContext: extractQuoteContext(rootNode, command),

compoundStructure: extractCompoundStructure(rootNode, command),

hasActualOperatorNodes: hasActualOperatorNodes(rootNode),

dangerousPatterns: extractDangerousPatterns(rootNode),

}