davaux 0.8.0

package/src/dev/remove.ts

@@ -0,0 +1,677 @@
+import { readFileSync, writeFileSync } from 'node:fs'
+
+export type RemoveResult = { removed: true; file: string } | { removed: false; error: string }
+
+function findComponentSpan(lines: string[], name: string, startFrom = 0): [number, number] | null {
+  const openRe = new RegExp(`^\\s*<${name}(\\s|/>|>|$)`)
+  let openIdx = -1
+  for (let i = startFrom; i < lines.length; i++) {
+    if (openRe.test(lines[i])) {
+      openIdx = i
+      break
+    }
+  }
+  if (openIdx === -1) return null
+
+  const openIndent = (lines[openIdx].match(/^(\s*)/) ?? ['', ''])[1]
+  const tagStart = lines[openIdx].indexOf(`<${name}`)
+  const rest = lines[openIdx].slice(tagStart)
+
+  // Single-line self-close or same-line children close
+  if (/\/>/.test(rest) || new RegExp(`</${name}>`).test(rest)) return [openIdx, openIdx]
+
+  // Multi-line: scan forward for /> or </Name> at same/shallower indent
+  for (let i = openIdx + 1; i < lines.length; i++) {
+    const t = lines[i].trim()
+    const ind = (lines[i].match(/^(\s*)/) ?? ['', ''])[1]
+    if ((t === '/>' || t.startsWith(`</${name}>`)) && ind.length <= openIndent.length + 2) {
+      return [openIdx, i]
+    }
+    // Bail if back to same/shallower indent on a non-close, non-blank line
+    if (t && ind.length <= openIndent.length && i > openIdx + 1) break
+  }
+
+  return [openIdx, openIdx]
+}
+
+export function removeJsx(filePath: string, componentName: string, instanceIndex?: number): RemoveResult {
+  let source: string
+  try {
+    source = readFileSync(filePath, 'utf-8')
+  } catch {
+    return { removed: false, error: `Cannot read file: ${filePath}` }
+  }
+
+  const lines = source.split('\n')
+
+  // Collect all spans for this component
+  const spans: [number, number][] = []
+  let from = 0
+  while (true) {
+    const span = findComponentSpan(lines, componentName, from)
+    if (!span) break
+    spans.push(span)
+    from = span[1] + 1
+  }
+
+  if (spans.length === 0) {
+    return { removed: false, error: `No <${componentName}> found in source.` }
+  }
+  const idx = instanceIndex ?? (spans.length === 1 ? 0 : -1)
+  if (idx === -1) {
+    return {
+      removed: false,
+      error: `${spans.length} instances of <${componentName}> found — click the specific one you want to remove, or edit the file directly.`,
+    }
+  }
+  if (idx >= spans.length) {
+    return { removed: false, error: `Instance ${idx} not found (${spans.length} instances exist).` }
+  }
+
+  const [start, end] = spans[idx]
+  lines.splice(start, end - start + 1)
+
+  // Collapse consecutive blank lines left by the removal
+  const cleaned: string[] = []
+  let prevBlank = false
+  for (const line of lines) {
+    const blank = line.trim() === ''
+    if (blank && prevBlank) continue
+    cleaned.push(line)
+    prevBlank = blank
+  }
+
+  try {
+    writeFileSync(filePath, cleaned.join('\n'), 'utf-8')
+  } catch {
+    return { removed: false, error: `Cannot write file: ${filePath}` }
+  }
+
+  return { removed: true, file: filePath }
+}
+
+export function removeElement(filePath: string, tagName: string, instanceIndex: number): RemoveResult {
+  let source: string
+  try {
+    source = readFileSync(filePath, 'utf-8')
+  } catch {
+    return { removed: false, error: `Cannot read file: ${filePath}` }
+  }
+
+  const lines = source.split('\n')
+  const span = findFullElementSpan(lines, tagName, instanceIndex)
+  if (!span) return { removed: false, error: `No <${tagName}> found at index ${instanceIndex}` }
+
+  const [start, end] = span
+  lines.splice(start, end - start + 1)
+
+  const cleaned: string[] = []
+  let prevBlank = false
+  for (const line of lines) {
+    const blank = line.trim() === ''
+    if (blank && prevBlank) continue
+    cleaned.push(line)
+    prevBlank = blank
+  }
+
+  try {
+    writeFileSync(filePath, cleaned.join('\n'), 'utf-8')
+  } catch {
+    return { removed: false, error: `Cannot write file: ${filePath}` }
+  }
+
+  return { removed: true, file: filePath }
+}
+
+export type ReplaceResult = { replaced: true; file: string } | { replaced: false; error: string }
+
+export type ReplaceElemResult = { replaced: true; file: string } | { replaced: false; error: string }
+
+// Find the span (start line, end line) of the Nth opening tag for `tagName`.
+// Matches <tag>, <tag />, <tag attr>, but NOT </tag>.
+function findElementTagSpan(lines: string[], tagName: string, instanceIndex: number): [number, number] | null {
+  const openRe = new RegExp(`<${tagName}(\\s|>|\\/)`)
+  let count = 0
+  for (let i = 0; i < lines.length; i++) {
+    if (openRe.test(lines[i])) {
+      if (count === instanceIndex) {
+        // If the opening tag closes on the same line, it's a one-liner
+        const tagPos = lines[i].search(openRe)
+        const rest = lines[i].slice(tagPos)
+        if (rest.includes('>')) return [i, i]
+        // Multi-line: scan forward for a line that is just > or />
+        for (let j = i + 1; j < lines.length; j++) {
+          const t = lines[j].trim()
+          if (t === '>' || t === '/>') return [i, j]
+        }
+        return [i, i]
+      }
+      count++
+    }
+  }
+  return null
+}
+
+function buildOpenTag(tagName: string, props: Record<string, unknown>, selfClose: boolean): string {
+  const entries = Object.entries(props).filter(([, v]) => v !== undefined && v !== null)
+  if (!entries.length) return selfClose ? `<${tagName} />` : `<${tagName}>`
+  const attrs = entries
+    .map(([k, v]) => {
+      if (v === true) return k
+      if (v === false) return null
+      if (typeof v === 'string') return `${k}="${v}"`
+      return `${k}={${JSON.stringify(v)}}`
+    })
+    .filter(Boolean)
+    .join(' ')
+  return attrs ? (selfClose ? `<${tagName} ${attrs} />` : `<${tagName} ${attrs}>`) : (selfClose ? `<${tagName} />` : `<${tagName}>`)
+}
+
+export function replaceElementAttrs(
+  filePath: string,
+  tagName: string,
+  newProps: Record<string, unknown>,
+  instanceIndex = 0,
+): ReplaceElemResult {
+  let source: string
+  try {
+    source = readFileSync(filePath, 'utf-8')
+  } catch {
+    return { replaced: false, error: `Cannot read file: ${filePath}` }
+  }
+
+  const lines = source.split('\n')
+  const span = findElementTagSpan(lines, tagName, instanceIndex)
+  if (!span) return { replaced: false, error: `No <${tagName}> found at index ${instanceIndex}` }
+
+  const [startLine, endLine] = span
+  const newLines = [...lines]
+  const openRe = new RegExp(`<${tagName}(\\s|>|\\/)`)
+
+  if (startLine === endLine) {
+    const line = lines[startLine]
+    const tagPos = line.search(openRe)
+    const before = line.slice(0, tagPos)
+    // Scan for closing > of the opening tag (simple scan — no nested > expected in common attrs)
+    let closePos = -1
+    let selfClose = false
+    for (let i = tagPos + tagName.length + 1; i < line.length; i++) {
+      if (line[i] === '>') {
+        if (line[i - 1] === '/') {
+          selfClose = true
+          closePos = i - 1
+        } else {
+          closePos = i
+        }
+        break
+      }
+    }
+    if (closePos === -1) return { replaced: false, error: `Cannot parse opening tag of <${tagName}>` }
+    const after = line.slice(selfClose ? closePos + 2 : closePos + 1)
+    newLines[startLine] = before + buildOpenTag(tagName, newProps, selfClose) + after
+  } else {
+    const firstLine = lines[startLine]
+    const tagPos = firstLine.search(openRe)
+    const before = firstLine.slice(0, tagPos)
+    const lastLine = lines[endLine]
+    const selfClose = lastLine.trim() === '/>'
+    const closeIdx = lastLine.indexOf(selfClose ? '/>' : '>')
+    const after = lastLine.slice(closeIdx + (selfClose ? 2 : 1))
+    newLines.splice(startLine, endLine - startLine + 1, before + buildOpenTag(tagName, newProps, selfClose) + after)
+  }
+
+  try {
+    writeFileSync(filePath, newLines.join('\n'), 'utf-8')
+  } catch {
+    return { replaced: false, error: `Cannot write file: ${filePath}` }
+  }
+
+  return { replaced: true, file: filePath }
+}
+
+// Replaces the inner text content of an element on a single line.
+// e.g. <h1>Old text</h1> → <h1>New text</h1>
+// Only works when the opening tag and closing tag are on the same line.
+export function replaceTextContent(
+  filePath: string,
+  tagName: string,
+  newText: string,
+  instanceIndex = 0,
+): ReplaceElemResult {
+  let source: string
+  try {
+    source = readFileSync(filePath, 'utf-8')
+  } catch {
+    return { replaced: false, error: `Cannot read file: ${filePath}` }
+  }
+
+  const lines = source.split('\n')
+  const span = findElementTagSpan(lines, tagName, instanceIndex)
+  if (!span) return { replaced: false, error: `No <${tagName}> found at index ${instanceIndex}` }
+
+  const [startLine, endLine] = span
+  const contentLine = endLine
+  const line = lines[contentLine]
+
+  const closeTag = `</${tagName}>`
+  const closeIdx = line.indexOf(closeTag)
+  if (closeIdx === -1) {
+    return { replaced: false, error: `<${tagName}> has multi-line content — not yet supported` }
+  }
+
+  // Find the end of the opening tag (simple > scan — no nested > expected in common attrs)
+  const openRe = new RegExp(`<${tagName}(\\s|>|\\/)`)
+  const tagStart = startLine === endLine ? line.search(openRe) : 0
+  let openEnd = -1
+  for (let i = tagStart; i < closeIdx; i++) {
+    if (line[i] === '>') {
+      openEnd = i
+      break
+    }
+  }
+  if (openEnd === -1) return { replaced: false, error: `Cannot parse opening tag of <${tagName}>` }
+
+  lines[contentLine] = line.slice(0, openEnd + 1) + newText + line.slice(closeIdx)
+
+  try {
+    writeFileSync(filePath, lines.join('\n'), 'utf-8')
+  } catch {
+    return { replaced: false, error: `Cannot write file: ${filePath}` }
+  }
+
+  return { replaced: true, file: filePath }
+}
+
+export function replaceJsx(
+  filePath: string,
+  componentName: string,
+  newJsx: string,
+  instanceIndex = 0,
+): ReplaceResult {
+  let source: string
+  try {
+    source = readFileSync(filePath, 'utf-8')
+  } catch {
+    return { replaced: false, error: `Cannot read file: ${filePath}` }
+  }
+
+  const lines = source.split('\n')
+  const spans: [number, number][] = []
+  let from = 0
+  while (true) {
+    const span = findComponentSpan(lines, componentName, from)
+    if (!span) break
+    spans.push(span)
+    from = span[1] + 1
+  }
+
+  if (spans.length === 0) {
+    return { replaced: false, error: `No <${componentName}> found in source.` }
+  }
+  if (instanceIndex >= spans.length) {
+    return {
+      replaced: false,
+      error: `Instance index ${instanceIndex} out of range (${spans.length} found).`,
+    }
+  }
+
+  const [start, end] = spans[instanceIndex]
+  const existingIndent = (lines[start].match(/^(\s*)/) ?? ['', ''])[1]
+  // Prepend existing indent to each line; newJsx lines already carry their own relative indent
+  const newLines = newJsx.split('\n').map((l) => (l === '' ? '' : existingIndent + l))
+
+  lines.splice(start, end - start + 1, ...newLines)
+
+  try {
+    writeFileSync(filePath, lines.join('\n'), 'utf-8')
+  } catch {
+    return { replaced: false, error: `Cannot write file: ${filePath}` }
+  }
+
+  return { replaced: true, file: filePath }
+}
+
+// Full element span: opening <tag through matching </tag> or />, using indent tracking.
+function findFullElementSpan(lines: string[], tagName: string, instanceIndex: number): [number, number] | null {
+  const openRe = new RegExp(`<${tagName}(\\s|>|\\/)`)
+  let count = 0
+  for (let i = 0; i < lines.length; i++) {
+    if (openRe.test(lines[i])) {
+      if (count === instanceIndex) {
+        const tagPos = lines[i].search(openRe)
+        const openIndent = (lines[i].match(/^(\s*)/) ?? ['', ''])[1]
+        const rest = lines[i].slice(tagPos)
+        if (/\/>/.test(rest) || new RegExp(`</${tagName}>`).test(rest)) return [i, i]
+        for (let j = i + 1; j < lines.length; j++) {
+          const t = lines[j].trim()
+          const ind = (lines[j].match(/^(\s*)/) ?? ['', ''])[1]
+          if (t.startsWith(`</${tagName}>`) && ind.length <= openIndent.length) return [i, j]
+          if (t && ind.length < openIndent.length) break
+        }
+        return [i, i]
+      }
+      count++
+    }
+  }
+  return null
+}
+
+export type FragmentResult =
+  | { found: true; content: string; file: string; name: string; instanceIndex: number }
+  | { found: false; error: string }
+
+/** Finds the content between a component's opening > and closing </Name>. */
+export function getComponentFragment(
+  filePath: string,
+  name: string,
+  instanceIndex: number,
+): FragmentResult {
+  let source: string
+  try {
+    source = readFileSync(filePath, 'utf-8')
+  } catch {
+    return { found: false, error: `Cannot read file: ${filePath}` }
+  }
+  const lines = source.split('\n')
+
+  // Collect all spans for this component
+  const spans: [number, number][] = []
+  let from = 0
+  while (true) {
+    const span = findComponentSpan(lines, name, from)
+    if (!span) break
+    spans.push(span)
+    from = span[1] + 1
+  }
+  if (instanceIndex >= spans.length)
+    return { found: false, error: `Instance ${instanceIndex} not found (${spans.length} instances exist)` }
+
+  const [spanStart, spanEnd] = spans[instanceIndex]
+  const startLine = lines[spanStart]
+  const tagStart = startLine.indexOf(`<${name}`)
+
+  // Self-closing — no children
+  if (/\/>/.test(startLine.slice(tagStart)))
+    return { found: false, error: `<${name}> is self-closing` }
+  if (spanStart === spanEnd)
+    return { found: false, error: `<${name}> opens and closes on the same line` }
+
+  // Find where the opening tag ends (the > that closes it)
+  const { line: openEndLine, col: openEndCol } = findOpenTagEnd(lines, spanStart, name)
+  if (openEndCol === -1)
+    return { found: false, error: `Cannot find end of opening tag for <${name}>` }
+
+  // Content = from after > on openEndLine up to (not including) the closing tag line
+  const contentLines: string[] = []
+  const afterOpen = lines[openEndLine].slice(openEndCol + 1)
+  if (afterOpen.trim()) contentLines.push(afterOpen)
+  for (let i = openEndLine + 1; i < spanEnd; i++) contentLines.push(lines[i])
+
+  return { found: true, content: contentLines.join('\n'), file: filePath, name, instanceIndex }
+}
+
+/** Replaces the children content of a component, preserving its opening and closing tags. */
+export function replaceComponentFragment(
+  filePath: string,
+  name: string,
+  instanceIndex: number,
+  newContent: string,
+): ReplaceResult {
+  let source: string
+  try {
+    source = readFileSync(filePath, 'utf-8')
+  } catch {
+    return { replaced: false, error: `Cannot read file: ${filePath}` }
+  }
+  const lines = source.split('\n')
+
+  const spans: [number, number][] = []
+  let from = 0
+  while (true) {
+    const span = findComponentSpan(lines, name, from)
+    if (!span) break
+    spans.push(span)
+    from = span[1] + 1
+  }
+  if (instanceIndex >= spans.length)
+    return { replaced: false, error: `Instance ${instanceIndex} not found` }
+
+  const [spanStart, spanEnd] = spans[instanceIndex]
+  const startLine = lines[spanStart]
+  const tagStart = startLine.indexOf(`<${name}`)
+  if (/\/>/.test(startLine.slice(tagStart)))
+    return { replaced: false, error: `<${name}> is self-closing` }
+  if (spanStart === spanEnd)
+    return { replaced: false, error: `<${name}> opens and closes on the same line` }
+
+  const { line: openEndLine, col: openEndCol } = findOpenTagEnd(lines, spanStart, name)
+  if (openEndCol === -1)
+    return { replaced: false, error: `Cannot find end of opening tag for <${name}>` }
+
+  // Preserve the opening tag lines (up to and including the >)
+  const openingLines = lines.slice(spanStart, openEndLine + 1)
+  openingLines[openingLines.length - 1] = openingLines[openingLines.length - 1].slice(0, openEndCol + 1)
+
+  const contentLines = newContent.trim() === '' ? [] : newContent.split('\n')
+  const replacement = [...openingLines, ...contentLines, lines[spanEnd]]
+
+  const newLines = [...lines]
+  newLines.splice(spanStart, spanEnd - spanStart + 1, ...replacement)
+
+  try {
+    writeFileSync(filePath, newLines.join('\n'), 'utf-8')
+  } catch {
+    return { replaced: false, error: `Cannot write file: ${filePath}` }
+  }
+  return { replaced: true, file: filePath }
+}
+
+function findOpenTagEnd(
+  lines: string[],
+  spanStart: number,
+  name: string,
+): { line: number; col: number } {
+  const firstLine = lines[spanStart]
+  const tagStart = firstLine.indexOf(`<${name}`)
+  // Scan the opening line for the closing >
+  for (let i = tagStart + name.length + 1; i < firstLine.length; i++) {
+    if (firstLine[i] === '>') return { line: spanStart, col: i }
+  }
+  // Multi-line tag — scan forward for a line that is just >
+  for (let i = spanStart + 1; i < lines.length; i++) {
+    const t = lines[i].trim()
+    if (t === '>') return { line: i, col: lines[i].indexOf('>') }
+  }
+  return { line: spanStart, col: -1 }
+}
+
+/** Finds the content between an HTML element's opening > and closing </tag>. */
+export function getElementFragment(
+  filePath: string,
+  tagName: string,
+  instanceIndex: number,
+): FragmentResult {
+  let source: string
+  try {
+    source = readFileSync(filePath, 'utf-8')
+  } catch {
+    return { found: false, error: `Cannot read file: ${filePath}` }
+  }
+  const lines = source.split('\n')
+  const span = findFullElementSpan(lines, tagName, instanceIndex)
+  if (!span) return { found: false, error: `No <${tagName}> found at index ${instanceIndex}` }
+
+  const [spanStart, spanEnd] = span
+  const { line: openEndLine, col: openEndCol } = findOpenTagEnd(lines, spanStart, tagName)
+  if (openEndCol === -1) return { found: false, error: `Cannot find end of opening tag for <${tagName}>` }
+
+  const contentLines: string[] = []
+  if (spanStart === spanEnd) {
+    // Single line: content between > and </tag>
+    const line = lines[spanStart]
+    const closeIdx = line.lastIndexOf(`</${tagName}>`)
+    if (closeIdx === -1) return { found: false, error: `Cannot find closing tag on same line` }
+    contentLines.push(line.slice(openEndCol + 1, closeIdx))
+  } else {
+    const afterOpen = lines[openEndLine].slice(openEndCol + 1)
+    if (afterOpen.trim()) contentLines.push(afterOpen)
+    for (let i = openEndLine + 1; i < spanEnd; i++) contentLines.push(lines[i])
+  }
+
+  return { found: true, content: contentLines.join('\n'), file: filePath, name: tagName, instanceIndex }
+}
+
+/** Replaces the children content of an HTML element, preserving its opening and closing tags. */
+export function replaceElementFragment(
+  filePath: string,
+  tagName: string,
+  instanceIndex: number,
+  newContent: string,
+): ReplaceResult {
+  let source: string
+  try {
+    source = readFileSync(filePath, 'utf-8')
+  } catch {
+    return { replaced: false, error: `Cannot read file: ${filePath}` }
+  }
+  const lines = source.split('\n')
+  const span = findFullElementSpan(lines, tagName, instanceIndex)
+  if (!span) return { replaced: false, error: `No <${tagName}> found at index ${instanceIndex}` }
+
+  const [spanStart, spanEnd] = span
+  const { line: openEndLine, col: openEndCol } = findOpenTagEnd(lines, spanStart, tagName)
+  if (openEndCol === -1) return { replaced: false, error: `Cannot find end of opening tag for <${tagName}>` }
+
+  const newLines = [...lines]
+  if (spanStart === spanEnd) {
+    const line = lines[spanStart]
+    const closeIdx = line.lastIndexOf(`</${tagName}>`)
+    if (closeIdx === -1) return { replaced: false, error: `Cannot find closing tag on same line` }
+    const before = line.slice(0, openEndCol + 1)
+    const after = line.slice(closeIdx)
+    const contentLines = newContent.trim() === '' ? [] : newContent.split('\n')
+    newLines.splice(spanStart, 1, ...(contentLines.length ? [before + contentLines[0], ...contentLines.slice(1), after] : [before + after]))
+  } else {
+    const openingLines = lines.slice(spanStart, openEndLine + 1)
+    openingLines[openingLines.length - 1] = openingLines[openingLines.length - 1].slice(0, openEndCol + 1)
+    const contentLines = newContent.trim() === '' ? [] : newContent.split('\n')
+    const replacement = [...openingLines, ...contentLines, lines[spanEnd]]
+    newLines.splice(spanStart, spanEnd - spanStart + 1, ...replacement)
+  }
+
+  try {
+    writeFileSync(filePath, newLines.join('\n'), 'utf-8')
+  } catch {
+    return { replaced: false, error: `Cannot write file: ${filePath}` }
+  }
+  return { replaced: true, file: filePath }
+}
+
+export type MoveResult = { moved: true; file: string } | { moved: false; error: string }
+
+// Moves a component or element up or down past its adjacent sibling in source.
+// Determines the sibling's span by scanning forward/backward using indent level —
+// no OML tree needed on the server side.
+export function moveNode(
+  filePath: string,
+  name: string,
+  isComponent: boolean,
+  instanceIndex: number,
+  direction: 'up' | 'down',
+): MoveResult {
+  let source: string
+  try {
+    source = readFileSync(filePath, 'utf-8')
+  } catch {
+    return { moved: false, error: `Cannot read file: ${filePath}` }
+  }
+
+  const lines = source.split('\n')
+
+  // Find the Nth instance of the target node
+  let targetSpan: [number, number] | null = null
+  if (isComponent) {
+    let from = 0
+    for (let idx = 0; idx <= instanceIndex; idx++) {
+      const s = findComponentSpan(lines, name, from)
+      if (!s) break
+      if (idx === instanceIndex) targetSpan = s
+      from = s[1] + 1
+    }
+  } else {
+    targetSpan = findFullElementSpan(lines, name, instanceIndex)
+  }
+
+  if (!targetSpan) return { moved: false, error: `No <${name}> found at index ${instanceIndex}` }
+
+  const [startA, endA] = targetSpan
+  const indA = (lines[startA].match(/^(\s*)/) ?? ['', ''])[1].length
+
+  let siblingSpan: [number, number] | null = null
+
+  if (direction === 'up') {
+    // Preceding sibling: its end is the first non-blank line before startA
+    let endB = startA - 1
+    while (endB >= 0 && lines[endB].trim() === '') endB--
+    if (endB < 0) return { moved: false, error: 'Already at top' }
+
+    // Scan backward from endB to find the sibling's start: first line at indA that opens a tag
+    let startB = endB
+    for (let j = endB - 1; j >= 0; j--) {
+      const t = lines[j].trim()
+      if (!t) continue
+      const ind = (lines[j].match(/^(\s*)/) ?? ['', ''])[1].length
+      if (ind < indA) break
+      if (ind === indA && t.startsWith('<') && !t.startsWith('</') && !t.startsWith('<!--')) {
+        startB = j
+        break
+      }
+    }
+    siblingSpan = [startB, endB]
+  } else {
+    // Following sibling: its start is the first non-blank line after endA
+    let startB = endA + 1
+    while (startB < lines.length && lines[startB].trim() === '') startB++
+    if (startB >= lines.length) return { moved: false, error: 'Already at bottom' }
+
+    const indB = (lines[startB].match(/^(\s*)/) ?? ['', ''])[1].length
+    const tagMatch = lines[startB].match(/<([A-Za-z][A-Za-z0-9_:-]*)/)
+    if (!tagMatch) return { moved: false, error: 'Cannot identify next sibling' }
+
+    const tagB = tagMatch[1]
+    const tagPos = lines[startB].indexOf(`<${tagB}`)
+    const restB = lines[startB].slice(tagPos)
+    let endB = startB
+
+    if (/\/>/.test(restB) || new RegExp(`</${tagB}>`).test(restB)) {
+      endB = startB
+    } else {
+      for (let j = startB + 1; j < lines.length; j++) {
+        const t = lines[j].trim()
+        const ind = (lines[j].match(/^(\s*)/) ?? ['', ''])[1].length
+        if ((t.startsWith(`</${tagB}>`) || t === '/>') && ind <= indB) { endB = j; break }
+        if (t && ind < indB) { endB = j - 1; break }
+      }
+    }
+    siblingSpan = [startB, endB]
+  }
+
+  // Swap the two spans (process in reverse order to preserve line indices)
+  const [first, second] =
+    targetSpan[0] < siblingSpan[0] ? [targetSpan, siblingSpan] : [siblingSpan, targetSpan]
+
+  const linesFirst = lines.slice(first[0], first[1] + 1)
+  const linesSecond = lines.slice(second[0], second[1] + 1)
+
+  const newLines = [...lines]
+  newLines.splice(second[0], second[1] - second[0] + 1, ...linesFirst)
+  newLines.splice(first[0], first[1] - first[0] + 1, ...linesSecond)
+
+  try {
+    writeFileSync(filePath, newLines.join('\n'), 'utf-8')
+  } catch {
+    return { moved: false, error: `Cannot write file: ${filePath}` }
+  }
+
+  return { moved: true, file: filePath }
+}