@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
764 lines (710 loc) • 29.9 kB
text/typescript
/**
* Source-preserving mutation for one plain block-map YAML fragment.
*
* Shared client settings are not ours to re-render. This scanner accepts only
* the small, unambiguous source shape we can patch byte-for-byte around the
* owned leaf. Every candidate is parsed again and compared with the complete
* expected document; unsupported YAML fails closed and never falls back to a
* whole-document serializer.
*/
import { parseSegment, selectIndex, type SelectorCriterion } from "./merge";
import { renderYaml } from "./serialize";
interface SourceLine {
start: number;
end: number;
body: string;
}
interface LocatedEntry {
lines: readonly SourceLine[];
index: number;
indent: number;
endIndex: number;
}
interface MissingEntry {
lines: readonly SourceLine[];
missingDepth: number;
indent: number;
insertAt: number;
}
interface ReplaceLineEntry {
lines: readonly SourceLine[];
index: number;
indent: number;
missingDepth: number;
}
type LocatedPath =
| { kind: "existing"; entry: LocatedEntry }
| { kind: "missing"; entry: MissingEntry }
// `key: {}` — an empty inline map the block-key scanner cannot see (#4260).
| { kind: "replace-line"; entry: ReplaceLineEntry }
// A populated flow container. Still refused, but nameable as its own cause.
| { kind: "unsupported-style" };
export type YamlFragmentMutation =
| { kind: "upsert"; value: unknown }
| { kind: "remove"; createdContainers: readonly string[] };
export type OmpYamlMutation =
| { kind: "upsert"; value: unknown }
| { kind: "remove"; removeEmptyProviders: boolean };
function sourceLines(text: string): SourceLine[] {
const lines: SourceLine[] = [];
const matcher = /[^\r\n]*(?:\r\n|\n|$)/gu;
for (const match of text.matchAll(matcher)) {
const raw = match[0];
if (raw.length === 0) continue;
const start = match.index;
const body = raw.endsWith("\r\n")
? raw.slice(0, -2)
: raw.endsWith("\n") ? raw.slice(0, -1) : raw;
lines.push({ start, end: start + raw.length, body });
}
return lines;
}
function leadingSpaces(line: string): number | null {
const leading = line.match(/^[ \t]*/u)?.[0] ?? "";
return leading.includes("\t") ? null : leading.length;
}
function isBlank(line: string): boolean {
return line.trim().length === 0;
}
function isComment(line: string): boolean {
return line.trimStart().startsWith("#");
}
/**
* The lexical state a scalar scan carries out of a line. Quoted and plain
* scalars may both continue onto later physical lines, so the state persists
* across the owned range: a continuation line opening with the scalar's
* closing quote is not a new opener — a ` #` behind it is a real comment —
* and a `#` on a line still inside an open quote is scalar content, not a
* comment.
*/
interface ScalarScan {
comment: boolean;
quote: "'" | "\"" | null;
scalarStarted: boolean;
}
/**
* Quote tracking has to work in both directions: a `#` inside a quoted scalar
* is content (`"model#variant"`), but a quote inside a plain scalar is also
* content — `user's model` is one plain scalar, and treating its `'` as an
* opener would hide a real ` #` comment behind quote mode.
*/
function scanScalarLine(line: string, quote: "'" | "\"" | null, scalarStarted: boolean): ScalarScan {
// A `'` or `"` opens a quoted scalar only where a scalar may begin — after
// `key:`, `- `, or a flow indicator — never inside a plain scalar already
// in progress.
let flowDepth = 0;
for (let index = 0; index < line.length; index += 1) {
const character = line[index]!;
if (quote === "\"") {
if (character === "\\") index += 1;
else if (character === quote) quote = null;
continue;
}
if (quote === "'") {
if (character !== quote) continue;
if (line[index + 1] === quote) index += 1;
else quote = null;
continue;
}
if (character === "#" && /\s/u.test(line[index - 1] ?? "")) {
return { comment: true, quote, scalarStarted };
}
const next = line[index + 1] ?? "";
if (scalarStarted) {
// `:` ends a plain scalar where a value boundary follows; inside flow
// collections `,`, `]`, and `}` do too.
if (character === ":" && (next === "" || /\s/u.test(next))) scalarStarted = false;
else if (flowDepth > 0 && (character === "," || character === "]" || character === "}")) {
scalarStarted = false;
if (character !== ",") flowDepth -= 1;
}
continue;
}
if (/\s/u.test(character)) continue;
if (character === "'" || character === "\"") {
quote = character;
continue;
}
if (character === "[" || character === "{") {
flowDepth += 1;
continue;
}
if (character === "]" || character === "}") {
flowDepth -= 1;
continue;
}
if (character === ",") continue;
// `key:`, `- `, `? `: indicators only where a value boundary follows.
if ((character === ":" || character === "-" || character === "?")
&& (next === "" || /\s/u.test(next))) continue;
// Anchors, aliases, and tags decorate the scalar that follows them.
if (character === "&" || character === "*" || character === "!") {
while (index + 1 < line.length && !/\s/u.test(line[index + 1]!)) index += 1;
continue;
}
scalarStarted = true;
}
return { comment: false, quote, scalarStarted };
}
function hasInlineComment(line: string): boolean {
return scanScalarLine(line, null, false).comment;
}
function regexpEscape(value: string): string {
return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
}
function isPlainBlockKey(line: string, indent: number, key: string): boolean {
const spaces = leadingSpaces(line);
if (spaces !== indent) return false;
const rest = line.slice(indent);
return new RegExp(`^${regexpEscape(key)}:[ ]*(?:#.*)?$`, "u").test(rest);
}
/** The inline value written after `key:` on this line, or null if the key is not here. */
function inlineValueAfterKey(line: string, indent: number, key: string): string | null {
const spaces = leadingSpaces(line);
if (spaces !== indent) return null;
const rest = line.slice(indent);
const head = `${key}:`;
// Compared as text, not as a pattern: a path segment is arbitrary user data,
// and brace escaping inside a `u`-flag regex is its own hazard.
if (!rest.startsWith(head)) return null;
return rest.slice(head.length).trim();
}
/** Exactly `key: {}` (any inner spacing) — an empty inline map, no inline comment. */
function isEmptyInlineMapKey(line: string, indent: number, key: string): boolean {
const value = inlineValueAfterKey(line, indent, key);
if (value === null) return false;
return value.startsWith("{") && value.endsWith("}") && value.slice(1, -1).trim().length === 0;
}
/** `key: { ... }` or `key: [ ... ]` on one line: content we would have to re-render. */
function isPopulatedInlineFlowKey(line: string, indent: number, key: string): boolean {
const value = inlineValueAfterKey(line, indent, key);
if (value === null) return false;
if (!value.startsWith("{") && !value.startsWith("[")) return false;
return !isEmptyInlineMapKey(line, indent, key);
}
/**
* A plain block key whose first child opens a flow collection:
*
* providers:
* { native: { ... } }
*
* DSH writes this shape itself. The walk passes straight through it — the key
* line is a plain block key and `containerEnd` does not stop at `}` — so the
* refusal used to surface only as a failed re-parse at the very end and got
* reported as a comment or formatting problem that was not there (#4260).
*/
function firstChildOpensFlow(
lines: readonly SourceLine[],
start: number,
end: number,
parentIndent: number,
): boolean {
for (let index = start + 1; index < end; index += 1) {
const body = lines[index]!.body;
if (isBlank(body) || isComment(body)) continue;
const spaces = leadingSpaces(body);
if (spaces === null || spaces <= parentIndent) continue;
const trimmed = body.trimStart();
return trimmed.startsWith("{") || trimmed.startsWith("[");
}
return false;
}
function containerEnd(lines: readonly SourceLine[], start: number, indent: number): number | null {
for (let index = start + 1; index < lines.length; index += 1) {
const body = lines[index]!.body;
const spaces = leadingSpaces(body);
if (spaces === null) return null;
if (isBlank(body)) continue;
if (isComment(body)) {
if (spaces <= indent) return index;
continue;
}
if (spaces <= indent) return index;
}
return lines.length;
}
function childEnd(
lines: readonly SourceLine[],
start: number,
parentEnd: number,
indent: number,
): number | null {
// Scalar state carries across physical lines: a scalar continuation is
// always deeper than the leaf's indent, so a `spaces <= indent` line can
// never be one. Inside an open quote a blank or `#`-leading line is scalar
// content; inside a plain scalar a blank line folds but a `#` line is still
// a real comment.
let quote: "'" | "\"" | null = null;
let scalarStarted = false;
for (let index = start + 1; index < parentEnd; index += 1) {
const body = lines[index]!.body;
const spaces = leadingSpaces(body);
if (spaces === null) return null;
// Blank lines and same-level comments remain outside our replacement.
// Deeper comments belong to the leaf and would be destroyed, so refuse.
if (isBlank(body)) {
if (quote !== null) continue;
if (!scalarStarted) return index;
// A plain scalar's blank line folds only when deeper content follows;
// otherwise it is the separator before a sibling and stays outside.
let ahead = index + 1;
while (ahead < parentEnd && isBlank(lines[ahead]!.body)) ahead += 1;
if (ahead >= parentEnd) return index;
const nextSpaces = leadingSpaces(lines[ahead]!.body);
if (nextSpaces === null) return null;
if (nextSpaces <= indent) return index;
index = ahead - 1;
continue;
}
if (quote === null && isComment(body)) return spaces <= indent ? index : null;
if (spaces <= indent) return index;
// A block sequence indicator opens a new node: scalar state never carries
// across item boundaries. Inside an open quote a leading `- ` is content.
const trimmed = body.trimStart();
if (quote === null && (trimmed === "-" || trimmed.startsWith("- "))) scalarStarted = false;
const scan = scanScalarLine(body, quote, scalarStarted);
if (scan.comment) return null;
quote = scan.quote;
scalarStarted = scan.scalarStarted;
}
return parentEnd;
}
function canonicalValue(value: unknown): unknown {
if (Array.isArray(value)) return value.map(canonicalValue);
if (value && typeof value === "object") {
return Object.fromEntries(
Object.entries(value as Record<string, unknown>)
.sort(([left], [right]) => left.localeCompare(right))
.map(([key, child]) => [key, canonicalValue(child)]),
);
}
return value;
}
function semanticallyMatches(text: string, expected: unknown): boolean {
try {
const parsed = text.trim().length === 0 ? {} : Bun.YAML.parse(text);
return JSON.stringify(canonicalValue(parsed)) === JSON.stringify(canonicalValue(expected));
} catch {
return false;
}
}
function lineEnding(text: string): "\n" | "\r\n" {
return text.includes("\r\n") ? "\r\n" : "\n";
}
function readPath(doc: unknown, path: readonly string[]): unknown {
let cursor = doc;
for (const key of path) {
if (cursor === null || typeof cursor !== "object" || Array.isArray(cursor)) return undefined;
cursor = (cursor as Record<string, unknown>)[key];
if (cursor === undefined) return undefined;
}
return cursor;
}
function isPlainRecord(value: unknown): value is Record<string, unknown> {
return value !== null && typeof value === "object" && !Array.isArray(value);
}
function immediateIndent(
lines: readonly SourceLine[],
start: number,
end: number,
parentIndent: number,
): number | null {
let indent: number | null = null;
for (let index = start; index < end; index += 1) {
const body = lines[index]!.body;
const spaces = leadingSpaces(body);
if (spaces === null) return null;
if (isBlank(body) || isComment(body) || spaces <= parentIndent) continue;
indent = indent === null ? spaces : Math.min(indent, spaces);
}
return indent ?? parentIndent + 2;
}
/** Locate a path only when every present segment is a plain block-map key. */
function locatePath(text: string, parsed: unknown, path: readonly string[]): LocatedPath | null {
if (path.length === 0 || !isPlainRecord(parsed)) return null;
const lines = sourceLines(text);
if (lines.some(line => leadingSpaces(line.body) === null)) return null;
let rangeStart = 0;
let rangeEnd = lines.length;
let parentIndent = -2;
const prefix: string[] = [];
for (let depth = 0; depth < path.length; depth += 1) {
const indent = depth === 0 ? 0 : immediateIndent(lines, rangeStart, rangeEnd, parentIndent);
if (indent === null) return null;
const matches: number[] = [];
for (let index = rangeStart; index < rangeEnd; index += 1) {
if (isPlainBlockKey(lines[index]!.body, indent, path[depth]!)) matches.push(index);
}
if (matches.length > 1) return null;
prefix.push(path[depth]!);
if (matches.length === 0) {
const seen = readPath(parsed, prefix);
// An empty inline map is the one flow shape we can adopt: rewriting that
// single line into block form adds our subtree and re-renders nothing the
// user wrote, because there is nothing in it (#4260).
const inline: number[] = [];
const populatedFlow: number[] = [];
for (let index = rangeStart; index < rangeEnd; index += 1) {
const body = lines[index]!.body;
if (isEmptyInlineMapKey(body, indent, path[depth]!)) inline.push(index);
else if (isPopulatedInlineFlowKey(body, indent, path[depth]!)) populatedFlow.push(index);
}
if (inline.length === 1 && isPlainRecord(seen) && Object.keys(seen).length === 0) {
return { kind: "replace-line", entry: { lines, index: inline[0]!, indent, missingDepth: depth } };
}
if (populatedFlow.length === 1 && seen !== undefined) return { kind: "unsupported-style" };
// The parser saw this key through syntax we do not patch (quoted/flow,
// merge aliases, or an ambiguous indentation shape).
if (seen !== undefined) return null;
const insertAt = rangeEnd < lines.length ? lines[rangeEnd]!.start : text.length;
return { kind: "missing", entry: { lines, missingDepth: depth, indent, insertAt } };
}
const index = matches[0]!;
const end = containerEnd(lines, index, indent);
if (end === null) return null;
if (depth === path.length - 1) {
if (hasInlineComment(lines[index]!.body)) return null;
const leafEnd = childEnd(lines, index, end, indent);
if (leafEnd === null) return null;
return { kind: "existing", entry: { lines, index, indent, endIndex: leafEnd } };
}
const container = readPath(parsed, prefix);
// `key:` with no children parses as null. The key line matched, so the
// missing-key branch above never runs, and `isPlainRecord(null)` is false —
// so an empty container used to refuse the whole document (#4260). Insert
// our subtree as its first child instead.
if (container === null) {
const insertAt = end < lines.length ? lines[end]!.start : text.length;
return {
kind: "missing",
entry: { lines, missingDepth: depth + 1, indent: indent + 2, insertAt },
};
}
if (!isPlainRecord(container)) return null;
if (firstChildOpensFlow(lines, index, end, indent)) return { kind: "unsupported-style" };
rangeStart = index + 1;
rangeEnd = end;
parentIndent = indent;
}
return null;
}
function nestedValue(path: readonly string[], value: unknown): Record<string, unknown> {
let nested: unknown = value;
for (let index = path.length - 1; index >= 0; index -= 1) nested = { [path[index]!]: nested };
return nested as Record<string, unknown>;
}
function rendered(value: unknown, indent: number, eol: "\n" | "\r\n"): string {
return renderYaml(value as Record<string, unknown>, indent).replaceAll("\n", eol);
}
function preserveFinalNewline(candidate: string, original: string, eol: "\n" | "\r\n"): string {
if (original.length > 0 && !original.endsWith("\n") && candidate.endsWith(eol)) {
return candidate.slice(0, -eol.length);
}
return candidate;
}
function upsertSource(
text: string,
parsed: unknown,
path: readonly string[],
value: unknown,
): string | null {
if (leadingSelector(path) !== null) return upsertSequenceEntry(text, parsed, path, value);
const located = locatePath(text, parsed, path);
if (located === null || located.kind === "unsupported-style") return null;
const eol = lineEnding(text);
if (located.kind === "existing") {
const { lines, index, indent, endIndex } = located.entry;
const startOffset = lines[index]!.start;
const endOffset = endIndex < lines.length ? lines[endIndex]!.start : text.length;
const candidate = `${text.slice(0, startOffset)}${rendered({ [path[path.length - 1]!]: value }, indent, eol)}${text.slice(endOffset)}`;
return preserveFinalNewline(candidate, text, eol);
}
if (located.kind === "replace-line") {
const { lines, index, indent, missingDepth } = located.entry;
const startOffset = lines[index]!.start;
const endOffset = index + 1 < lines.length ? lines[index + 1]!.start : text.length;
const insertion = rendered(nestedValue(path.slice(missingDepth), value), indent, eol);
return preserveFinalNewline(`${text.slice(0, startOffset)}${insertion}${text.slice(endOffset)}`, text, eol);
}
const { missingDepth, indent, insertAt } = located.entry;
const prefix = insertAt > 0 && !text.slice(0, insertAt).endsWith("\n") ? eol : "";
const insertion = rendered(nestedValue(path.slice(missingDepth), value), indent, eol);
const candidate = `${text.slice(0, insertAt)}${prefix}${insertion}${text.slice(insertAt)}`;
return preserveFinalNewline(candidate, text, eol);
}
/**
* The criteria of a path whose first segment selects one entry of a top-level
* sequence, or null for an ordinary block-map path.
*
* DSH 0.1.7+ keeps settings in a profile patch: a YAML list of loader rows,
* `- id: llm-pi-ai` among them. The entry is patched as the block map it is
* once its `- ` indicator and two-space continuation indent are set aside, and
* both are put back byte for byte. Every other list shape fails closed.
*/
function leadingSelector(path: readonly string[]): readonly SelectorCriterion[] | null {
if (path.length === 0) return null;
const segment = parseSegment(path[0]!);
return segment.kind === "select" ? segment.criteria : null;
}
/** Line ranges of a block sequence's top-level entries, or null for any other document shape. */
function topLevelEntries(lines: readonly SourceLine[]): Array<{ start: number; end: number }> | null {
const entries: Array<{ start: number; end: number }> = [];
let open = false;
for (let index = 0; index < lines.length; index += 1) {
const body = lines[index]!.body;
if (isBlank(body)) continue;
const spaces = leadingSpaces(body);
if (spaces === null) return null;
if (spaces > 0) {
// Continuation of the open entry; deeper text anywhere else is not a list we can place.
if (!open) return null;
continue;
}
if (open) entries[entries.length - 1]!.end = index;
open = false;
if (isComment(body)) continue;
if (!/^- \S/u.test(body)) return null;
entries.push({ start: index, end: lines.length });
open = true;
}
return entries;
}
/** The entry's text as the block map it holds, or null when it is not in the two-space form. */
function entrySource(text: string, lines: readonly SourceLine[], start: number, end: number): string | null {
let source = "";
for (let index = start; index < end; index += 1) {
const line = lines[index]!;
const raw = text.slice(line.start, line.end);
if (index === start) source += raw.slice(2);
else if (isBlank(line.body)) source += raw;
else if ((leadingSpaces(line.body) ?? 0) >= 2) source += raw.slice(2);
else return null;
}
return source;
}
/** Put an entry back: `- ` on its first line, two spaces on every other non-blank line. */
function reindentEntry(source: string): string {
return sourceLines(source).map((line, index) => {
const raw = source.slice(line.start, line.end);
if (index === 0) return `- ${raw}`;
return isBlank(line.body) ? raw : ` ${raw}`;
}).join("");
}
function firstLine(text: string): string {
return text.split(/\r?\n/u, 1)[0] ?? "";
}
type SequenceEntry =
| {
kind: "found";
criteria: readonly SelectorCriterion[];
rest: readonly string[];
/** Byte range of the entry, trailing blank lines included. */
startOffset: number;
endOffset: number;
source: string;
parsed: Record<string, unknown>;
/** Entries the list keeps if this one is removed. */
siblings: number;
}
| {
kind: "missing";
criteria: readonly SelectorCriterion[];
rest: readonly string[];
/** Where a new entry goes, and the end of the `[]` line it replaces, if any. */
insertAt: number;
replaceEnd: number | null;
};
function sequenceEntry(text: string, parsed: unknown, path: readonly string[]): SequenceEntry | null {
const criteria = leadingSelector(path);
if (criteria === null || !Array.isArray(parsed)) return null;
const lines = sourceLines(text);
const rest = path.slice(1);
const found = selectIndex(parsed, criteria);
const entries = topLevelEntries(lines);
if (entries === null) {
// `[]` is how DSH writes a profile patch with no rows yet: the one flow form adopted.
const content = lines.filter(line => !isBlank(line.body) && !isComment(line.body));
if (found >= 0 || parsed.length !== 0 || content.length !== 1 || content[0]!.body.trimEnd() !== "[]") return null;
return { kind: "missing", criteria, rest, insertAt: content[0]!.start, replaceEnd: content[0]!.end };
}
if (entries.length !== parsed.length) return null;
if (found < 0) return { kind: "missing", criteria, rest, insertAt: text.length, replaceEnd: null };
const element = parsed[found];
const { start, end } = entries[found]!;
const source = entrySource(text, lines, start, end);
if (!isPlainRecord(element) || source === null) return null;
return {
kind: "found",
criteria,
rest,
startOffset: lines[start]!.start,
endOffset: end < lines.length ? lines[end]!.start : text.length,
source,
parsed: element,
siblings: entries.length - 1,
};
}
function spliceEntry(text: string, entry: Extract<SequenceEntry, { kind: "found" }>, replacement: string): string {
return `${text.slice(0, entry.startOffset)}${replacement}${text.slice(entry.endOffset)}`;
}
function upsertSequenceEntry(text: string, parsed: unknown, path: readonly string[], value: unknown): string | null {
const entry = sequenceEntry(text, parsed, path);
if (entry === null) return null;
const eol = lineEnding(text);
if (entry.kind === "found") {
if (entry.rest.length === 0) return null;
const patched = upsertSource(entry.source, entry.parsed, entry.rest, value);
// The `- ` belongs to the entry's first line; a patch that rewrote that line cannot take it back.
if (patched === null || firstLine(patched) !== firstLine(entry.source)) return null;
return preserveFinalNewline(spliceEntry(text, entry, reindentEntry(patched)), text, eol);
}
// The same element `setPath` seeds: the selector's own fields, then the fragment beneath them.
const seeded = Object.fromEntries(entry.criteria.map(criterion => [criterion.field, criterion.value]));
const element = entry.rest.length === 0 ? value : { ...seeded, ...nestedValue(entry.rest, value) };
if (!isPlainRecord(element)) return null;
const item = reindentEntry(rendered(element, 0, eol));
if (entry.replaceEnd !== null) {
return preserveFinalNewline(`${text.slice(0, entry.insertAt)}${item}${text.slice(entry.replaceEnd)}`, text, eol);
}
const prefix = text.length > 0 && !text.endsWith("\n") ? eol : "";
return preserveFinalNewline(`${text}${prefix}${item}`, text, eol);
}
function removeSequenceEntryPath(
text: string,
parsed: unknown,
path: readonly string[],
requireEmpty: boolean,
): string | null {
const entry = sequenceEntry(text, parsed, path);
if (entry === null || entry.kind !== "found") return null;
if (entry.rest.length > 0) {
const patched = removeExactPath(entry.source, entry.rest, requireEmpty);
if (patched === null || firstLine(patched) !== firstLine(entry.source)) return null;
return spliceEntry(text, entry, reindentEntry(patched));
}
if (requireEmpty) {
// A pruned entry may still hold what its selector seeded, and nothing else.
const seededOnly = Object.keys(entry.parsed).length === entry.criteria.length
&& selectIndex([entry.parsed], entry.criteria) === 0;
if (!seededOnly || sourceLines(entry.source).some(line => hasInlineComment(line.body) || isComment(line.body))) {
return null;
}
}
// A list left with no entries goes back to the `[]` DSH writes for an empty one.
const eol = lineEnding(text);
return preserveFinalNewline(spliceEntry(text, entry, entry.siblings === 0 ? `[]${eol}` : ""), text, eol);
}
function removeExactPath(text: string, path: readonly string[], requireEmpty: boolean): string | null {
let parsed: unknown;
try {
parsed = text.trim().length === 0 ? {} : Bun.YAML.parse(text);
} catch {
return null;
}
if (leadingSelector(path) !== null) return removeSequenceEntryPath(text, parsed, path, requireEmpty);
const located = locatePath(text, parsed, path);
if (located === null || located.kind !== "existing") return null;
const { lines, index, endIndex } = located.entry;
const startOffset = lines[index]!.start;
const endOffset = endIndex < lines.length ? lines[endIndex]!.start : text.length;
if (requireEmpty) {
const sourceBody = text.slice(lines[index]!.end, endOffset);
if (sourceBody.trim().length > 0) return null;
}
return `${text.slice(0, startOffset)}${text.slice(endOffset)}`;
}
function planSourceRemoval(
text: string,
path: readonly string[],
createdContainers: readonly string[],
): { text: string; prunedContainers: string[] } | null {
let next = removeExactPath(text, path, false);
if (next === null) return null;
const created = new Set(createdContainers);
const prunedContainers: string[] = [];
for (let depth = path.length - 1; depth >= 1; depth -= 1) {
const containerPath = path.slice(0, depth);
const encoded = containerPath.join("\u0000");
if (!created.has(encoded)) continue;
const pruned = removeExactPath(next, containerPath, true);
// A user-added sibling/comment makes this ancestor source-owned now. Keep
// it (and every parent) while still removing our leaf.
if (pruned === null) break;
next = pruned;
prunedContainers.push(encoded);
}
return { text: preserveFinalNewline(next, text, lineEnding(text)), prunedContainers };
}
/** Containers whose source ranges are still empty and safe to prune. */
export function sourcePrunableYamlContainers(
text: string,
path: readonly string[],
createdContainers: readonly string[],
): readonly string[] | null {
return planSourceRemoval(text, path, createdContainers)?.prunedContainers ?? null;
}
function removeSource(
text: string,
path: readonly string[],
createdContainers: readonly string[],
): string | null {
return planSourceRemoval(text, path, createdContainers)?.text ?? null;
}
/**
* Patch one arbitrary plain block-map path, preserving every other byte.
*/
export function patchYamlFragmentSource(
text: string,
path: readonly string[],
mutation: YamlFragmentMutation,
expected: unknown,
): string | null {
let parsed: unknown;
try {
parsed = text.trim().length === 0 ? {} : Bun.YAML.parse(text);
} catch {
return null;
}
const patched = mutation.kind === "upsert"
? upsertSource(text, parsed, path, mutation.value)
: removeSource(text, path, mutation.createdContainers);
return patched !== null && semanticallyMatches(patched, expected) ? patched : null;
}
/**
* True when a refusal on this path is caused by a flow-style container rather
* than by comments or formatting we would have to re-render. DSH writes that
* shape itself, so naming it is the difference between an actionable message
* and one that sends the user hunting for a comment that is not there (#4260).
*/
export function yamlFragmentUnsupportedStyle(text: string, path: readonly string[]): boolean {
let parsed: unknown;
try {
parsed = text.trim().length === 0 ? {} : Bun.YAML.parse(text);
} catch {
return false;
}
if (leadingSelector(path) !== null) {
const entry = sequenceEntry(text, parsed, path);
return entry?.kind === "found" && entry.rest.length > 0
&& locatePath(entry.source, entry.parsed, entry.rest)?.kind === "unsupported-style";
}
return locatePath(text, parsed, path)?.kind === "unsupported-style";
}
/** Backward-compatible OMP wrapper around the generic path patcher. */
export function patchOmpYamlSource(
text: string,
mutation: OmpYamlMutation,
expected: unknown,
): string | null {
return patchYamlFragmentSource(
text,
["providers", "opencodex"],
mutation.kind === "upsert"
? mutation
: {
kind: "remove",
createdContainers: mutation.removeEmptyProviders ? ["providers"] : [],
},
expected,
);
}