@bdsqqq/pi 0.0.1

package/dist/core/box-chrome.js

@@ -0,0 +1,207 @@
+//#region packages/core/box-chrome/index.ts
+function boxTop(args) {
+	const { variant, style, innerWidth = 0, header } = args;
+	if (variant === "open") return header ? style.dim("╭─[") + header.text + style.dim("]") : style.dim("╭─");
+	if (!header) return style.dim("╭" + "─".repeat(innerWidth) + "╮");
+	const right = Math.max(0, innerWidth - 1 - header.width);
+	return style.dim("╭─") + header.text + style.dim("─".repeat(right) + "╮");
+}
+function boxRow(args) {
+	const { variant, style, inner } = args;
+	return variant === "closed" ? style.dim("│") + inner + style.dim("│") : style.dim("│ ") + inner;
+}
+/**
+* Border line with left AND right labels, separated by ─ fill.
+* Used by the editor for: ╭─ left ──── right ─╮ / ╰─ left ──── right ─╯
+*
+* Always renders a ─ after the left corner and before the right corner
+* (the "edge dashes"), so labels never touch the corners directly.
+* innerWidth is the space between the two corner characters.
+*/
+function boxBorderLR(args) {
+	const { corner, style, innerWidth, left, right } = args;
+	const leftW = left?.width ?? 0;
+	const rightW = right?.width ?? 0;
+	const fill = innerWidth - 2 - leftW - rightW;
+	if (fill < 0) return style.dim(corner.left + "─".repeat(Math.max(0, innerWidth)) + corner.right);
+	return style.dim(corner.left + "─") + (left ? left.text : "") + style.dim("─".repeat(fill)) + (right ? right.text : "") + style.dim("─" + corner.right);
+}
+function boxBottom(args) {
+	const { variant, style, innerWidth = 0, footer } = args;
+	if (variant === "open") return style.dim("╰────");
+	if (!footer) return style.dim("╰" + "─".repeat(innerWidth) + "╯");
+	const left = Math.max(0, Math.floor((innerWidth - footer.width) / 2));
+	const right = Math.max(0, innerWidth - left - footer.width);
+	return style.dim("╰" + "─".repeat(left)) + footer.text + style.dim("─".repeat(right) + "╯");
+}
+if (import.meta.vitest) {
+	const { describe, it, expect } = import.meta.vitest;
+	const identity = { dim: (s) => s };
+	describe("boxTop", () => {
+		it("open variant without header", () => {
+			expect(boxTop({
+				variant: "open",
+				style: identity
+			})).toBe("╭─");
+		});
+		it("open variant with header", () => {
+			expect(boxTop({
+				variant: "open",
+				style: identity,
+				header: {
+					text: "title",
+					width: 5
+				}
+			})).toBe("╭─[title]");
+		});
+		it("closed variant without header", () => {
+			expect(boxTop({
+				variant: "closed",
+				style: identity,
+				innerWidth: 5
+			})).toBe("╭─────╮");
+		});
+		it("closed variant with header", () => {
+			expect(boxTop({
+				variant: "closed",
+				style: identity,
+				innerWidth: 10,
+				header: {
+					text: "hi",
+					width: 2
+				}
+			})).toBe("╭─hi───────╮");
+		});
+	});
+	describe("boxRow", () => {
+		it("open variant", () => {
+			expect(boxRow({
+				variant: "open",
+				style: identity,
+				inner: "text"
+			})).toBe("│ text");
+		});
+		it("closed variant", () => {
+			expect(boxRow({
+				variant: "closed",
+				style: identity,
+				inner: "text"
+			})).toBe("│text│");
+		});
+	});
+	describe("boxBorderLR", () => {
+		it("no labels", () => {
+			expect(boxBorderLR({
+				corner: {
+					left: "╭",
+					right: "╮"
+				},
+				style: identity,
+				innerWidth: 6
+			})).toBe("╭──────╮");
+		});
+		it("left label only", () => {
+			expect(boxBorderLR({
+				corner: {
+					left: "╭",
+					right: "╮"
+				},
+				style: identity,
+				innerWidth: 10,
+				left: {
+					text: "L",
+					width: 1
+				}
+			})).toBe("╭─L────────╮");
+		});
+		it("right label only", () => {
+			expect(boxBorderLR({
+				corner: {
+					left: "╭",
+					right: "╮"
+				},
+				style: identity,
+				innerWidth: 10,
+				right: {
+					text: "R",
+					width: 1
+				}
+			})).toBe("╭────────R─╮");
+		});
+		it("both labels", () => {
+			expect(boxBorderLR({
+				corner: {
+					left: "╭",
+					right: "╮"
+				},
+				style: identity,
+				innerWidth: 12,
+				left: {
+					text: "L",
+					width: 1
+				},
+				right: {
+					text: "R",
+					width: 1
+				}
+			})).toBe("╭─L────────R─╮");
+		});
+		it("overflow falls back to plain dashed line", () => {
+			expect(boxBorderLR({
+				corner: {
+					left: "╭",
+					right: "╮"
+				},
+				style: identity,
+				innerWidth: 4,
+				left: {
+					text: "LONG",
+					width: 4
+				},
+				right: {
+					text: "X",
+					width: 1
+				}
+			})).toBe("╭────╮");
+		});
+	});
+	describe("boxBottom", () => {
+		it("open variant", () => {
+			expect(boxBottom({
+				variant: "open",
+				style: identity
+			})).toBe("╰────");
+		});
+		it("closed variant without footer", () => {
+			expect(boxBottom({
+				variant: "closed",
+				style: identity,
+				innerWidth: 5
+			})).toBe("╰─────╯");
+		});
+		it("closed variant with centered footer", () => {
+			expect(boxBottom({
+				variant: "closed",
+				style: identity,
+				innerWidth: 10,
+				footer: {
+					text: "ok",
+					width: 2
+				}
+			})).toBe("╰────ok────╯");
+		});
+		it("footer centering handles odd widths", () => {
+			expect(boxBottom({
+				variant: "closed",
+				style: identity,
+				innerWidth: 9,
+				footer: {
+					text: "ok",
+					width: 2
+				}
+			})).toBe("╰───ok────╯");
+		});
+	});
+}
+//#endregion
+export { boxBorderLR, boxBottom, boxRow, boxTop };

package/dist/core/box-format.d.ts

@@ -0,0 +1,82 @@
+import { Excerpt } from "./show.js";
+import { Component } from "@mariozechner/pi-tui";
+
+//#region packages/core/box-format/index.d.ts
+interface BoxLine {
+  /** optional gutter text (e.g., line number). right-aligned to gutter width. */
+  gutter?: string;
+  /** line content */
+  text: string;
+  /** when true, gutter + content render at base color instead of dim */
+  highlight?: boolean;
+}
+interface BoxBlock {
+  lines: BoxLine[];
+}
+interface BoxSection {
+  /** text inside ╭─[...]. omit for headless boxes (no opening line). */
+  header?: string;
+  /** contiguous blocks. gaps between blocks show · elision marker. */
+  blocks: BoxBlock[];
+}
+interface BoxWindowedOpts {
+  /** max sections to show (rest get "… N more" footer) */
+  maxSections?: number;
+  /**
+  * excerpts applied independently to each block's visual lines.
+  * e.g., [{ focus: "head", context: 12 }, { focus: "tail", context: 13 }]
+  * caps each block at 25 visual lines (head 12 + tail 13).
+  */
+  excerpts?: Excerpt[];
+}
+/**
+* visual-line-aware box renderer.
+*
+* pipeline: compute chrome width → expand to visual lines at content width
+* → window per-block via excerpts → render chrome around the result.
+*
+* wraps content to fit width
+* via pi-tui Text.render(). truncateToWidth is kept as a safety net.
+*
+* usage:
+*   formatBoxesWindowed(
+*     sections,
+*     { excerpts: [{ focus: "head", context: 12 }, { focus: "tail", context: 13 }] },
+*     ["some notice"],
+*     90,
+*   )
+*/
+declare function formatBoxesWindowed(sections: BoxSection[], opts?: BoxWindowedOpts, notices?: string[], width?: number): string;
+/**
+* convenience: wrap a single text block in a box section with no gutter.
+* all lines get highlight=true (base color) by default.
+*/
+declare function textSection(header: string | undefined, text: string, dim?: boolean): BoxSection;
+/**
+* visual-line-aware boxRenderer. uses formatBoxesWindowed under the hood.
+* caches by (width, expanded).
+*/
+declare function boxRendererWindowed(buildSections: () => BoxSection[], opts: {
+  collapsed: BoxWindowedOpts;
+  expanded: BoxWindowedOpts;
+}, notices?: string[], expanded?: boolean): Component & {
+  invalidate(): void;
+};
+/**
+* wrap visible text in an OSC 8 terminal hyperlink.
+* terminals that support OSC 8 render this as a clickable link;
+* others silently ignore the sequences and show plain text.
+*/
+declare function osc8Link(url: string, text: string): string;
+/**
+* standardized call-line component for renderCall.
+* renders: bold(label) dim(context)
+*
+* usage: renderCallLine("Edit", "~/path/to/file.ts", theme)
+*/
+declare function renderCallLine(label: string, context: string, theme: any): {
+  render(width: number): string[];
+  invalidate(): void;
+};
+//#endregion
+export { BoxBlock, BoxLine, BoxSection, BoxWindowedOpts, type Excerpt, boxRendererWindowed, formatBoxesWindowed, osc8Link, renderCallLine, textSection };

package/dist/core/box-format.js

@@ -0,0 +1,381 @@
+import { boxBottom, boxTop } from "./box-chrome.js";
+import { windowItems } from "./show.js";
+import { Text } from "@mariozechner/pi-tui";
+//#region packages/core/box-format/index.ts
+/**
+* box-format — shared diagnostic-style box renderer for tool output.
+*
+* produces miette/ariadne-style box-drawing output:
+*   ╭─[header text]
+*    42 │ highlighted line (base-color gutter)
+*    43 │ dim context line
+*       ·
+*   100 │ another block
+*   ╰────
+*
+* chrome (╭│╰─·) renders DIM. highlighted lines get base-color
+* gutter + content; non-highlighted lines are fully dim.
+* tools without line numbers omit the gutter column.
+*
+* pipeline: callers produce BoxSection[], optionally pass Excerpt[] for
+* per-block visual-line windowing. box-format computes chrome width,
+* expands content to visual lines at (width - chrome), applies
+* windowItems() from show.ts, then wraps the result in box chrome.
+*
+* IMPORTANT: all output lines are truncated to the provided `width`
+* via truncateToWidth() as a safety net. the TUI will crash if any
+* rendered line exceeds terminal width.
+*/
+const DIM = "\x1B[2m";
+const RST = "\x1B[0m";
+/**
+* ANSI-aware visible width + truncation.
+* pi-tui exports these too (with better wide-char support), but we
+* keep local versions so box-format works in test environments where
+* pi-tui isn't available.
+*/
+const ANSI_RE = /\x1b\[[0-9;]*m|\x1b\]8;;[^\x07]*\x07/g;
+/** tab stop width — terminals default to 8 but most code uses 4 */
+const TAB_WIDTH = 4;
+function visibleWidth$1(text) {
+	const stripped = text.replace(ANSI_RE, "");
+	let w = 0;
+	for (const ch of stripped) w += ch === "	" ? TAB_WIDTH : 1;
+	return w;
+}
+function truncateToWidth$1(text, maxWidth, ellipsis = "…") {
+	if (visibleWidth$1(text) <= maxWidth) return text;
+	const target = maxWidth - ellipsis.length;
+	if (target <= 0) return ellipsis.slice(0, maxWidth);
+	let visible = 0;
+	let i = 0;
+	while (i < text.length && visible < target) {
+		if (text[i] === "\x1B" && text[i + 1] === "[") {
+			const end = text.indexOf("m", i);
+			if (end !== -1) {
+				i = end + 1;
+				continue;
+			}
+		}
+		if (text[i] === "\x1B" && text[i + 1] === "]") {
+			const end = text.indexOf("\x07", i);
+			if (end !== -1) {
+				i = end + 1;
+				continue;
+			}
+		}
+		visible += text[i] === "	" ? TAB_WIDTH : 1;
+		i++;
+	}
+	return text.slice(0, i) + RST + ellipsis;
+}
+/**
+* defensive padding subtracted from width before truncating.
+* the pi TUI passes the content-area width to render(), but
+* border/padding chars can still cause off-by-one wrapping
+* that eats subsequent lines. 2 chars is conservative enough
+* to prevent wrapping without wasting visible space.
+*/
+const WIDTH_SAFETY_MARGIN = 2;
+/**
+* expand a block's logical BoxLine[] to visual lines at contentWidth.
+* wrapping is done by pi-tui's Text.render(). first visual line of
+* a wrapped logical line gets the gutter; continuation lines get "".
+*/
+function expandBlock(block, contentWidth) {
+	const result = [];
+	for (const line of block.lines) {
+		const visualLines = contentWidth > 0 ? new Text(line.text, 0, 0).render(contentWidth) : [line.text];
+		for (let i = 0; i < visualLines.length; i++) {
+			const visualLine = visualLines[i];
+			if (visualLine === void 0) continue;
+			result.push({
+				text: visualLine,
+				gutter: i === 0 ? line.gutter ?? "" : "",
+				highlight: line.highlight ?? false,
+				isElision: false,
+				isGap: false
+			});
+		}
+	}
+	return result;
+}
+/**
+* compute the chrome prefix width for a given gutter width.
+* with gutter:  "  42 │ " = gutterWidth + 3
+* without:      "│ "      = 2
+*/
+function chromeWidth(gutterWidth) {
+	return gutterWidth > 0 ? gutterWidth + 3 : 2;
+}
+/**
+* visual-line-aware box renderer.
+*
+* pipeline: compute chrome width → expand to visual lines at content width
+* → window per-block via excerpts → render chrome around the result.
+*
+* wraps content to fit width
+* via pi-tui Text.render(). truncateToWidth is kept as a safety net.
+*
+* usage:
+*   formatBoxesWindowed(
+*     sections,
+*     { excerpts: [{ focus: "head", context: 12 }, { focus: "tail", context: 13 }] },
+*     ["some notice"],
+*     90,
+*   )
+*/
+function formatBoxesWindowed(sections, opts = {}, notices, width) {
+	const maxSections = opts.maxSections ?? sections.length;
+	const excerpts = opts.excerpts ?? [];
+	const shown = sections.slice(0, maxSections);
+	const out = [];
+	const safeWidth = width != null ? Math.max(1, width - WIDTH_SAFETY_MARGIN) : void 0;
+	const clamp = (line) => safeWidth != null ? truncateToWidth$1(line, safeWidth, "…") : line;
+	const chrome = { dim: (s) => `${DIM}${s}${RST}` };
+	for (let si = 0; si < shown.length; si++) {
+		const section = shown[si];
+		if (!section) continue;
+		const allGutters = section.blocks.flatMap((b) => b.lines.map((l) => l.gutter ?? ""));
+		const gw = Math.max(0, ...allGutters.map((g) => g.length));
+		const pad = " ".repeat(gw);
+		const cw = chromeWidth(gw);
+		const contentWidth = safeWidth != null ? Math.max(1, safeWidth - cw) : 80;
+		if (si > 0) out.push("");
+		if (section.header != null) out.push(clamp(boxTop({
+			variant: "open",
+			style: chrome,
+			header: {
+				text: section.header,
+				width: section.header.replace(/\x1b\[[0-9;]*m/g, "").length
+			}
+		})));
+		for (let bi = 0; bi < section.blocks.length; bi++) {
+			const block = section.blocks[bi];
+			if (!block) continue;
+			if (bi > 0) out.push(gw > 0 ? `${DIM}${pad} ·${RST}` : `${DIM}·${RST}`);
+			const expanded = expandBlock(block, contentWidth);
+			const windowed = excerpts.length > 0 ? windowItems(expanded, excerpts, (count) => ({
+				text: `· ··· ${count} more lines`,
+				gutter: "",
+				highlight: false,
+				isElision: true,
+				isGap: false
+			})) : {
+				items: expanded,
+				skippedRanges: []
+			};
+			if (windowed.skippedRanges.length > 0);
+			for (const vl of windowed.items) if (vl.isElision) {
+				const prefix = gw > 0 ? `${pad} ` : "";
+				out.push(`${DIM}${prefix}${vl.text}${RST}`);
+			} else if (gw > 0) {
+				const gutter = vl.gutter.padStart(gw);
+				if (vl.highlight) out.push(clamp(`${gutter} ${DIM}│${RST} ${vl.text}`));
+				else out.push(clamp(`${DIM}${gutter} │ ${vl.text}${RST}`));
+			} else if (vl.highlight) out.push(clamp(`${DIM}│${RST} ${vl.text}`));
+			else out.push(clamp(`${DIM}│ ${vl.text}${RST}`));
+		}
+		out.push(boxBottom({
+			variant: "open",
+			style: chrome
+		}));
+	}
+	if (sections.length > maxSections) {
+		const rem = sections.length - maxSections;
+		out.push(`${DIM}… ${rem} more${RST}`);
+	}
+	if (notices?.length) {
+		out.push("");
+		out.push(clamp(`${DIM}[${notices.join(". ")}]${RST}`));
+	}
+	return out.join("\n");
+}
+/**
+* convenience: wrap a single text block in a box section with no gutter.
+* all lines get highlight=true (base color) by default.
+*/
+function textSection(header, text, dim = false) {
+	return {
+		...header != null && { header },
+		blocks: [{ lines: text.split("\n").map((line) => ({
+			text: line,
+			highlight: !dim
+		})) }]
+	};
+}
+/**
+* visual-line-aware boxRenderer. uses formatBoxesWindowed under the hood.
+* caches by (width, expanded).
+*/
+function boxRendererWindowed(buildSections, opts, notices, expanded = false) {
+	let cachedWidth;
+	let cachedExpanded;
+	let cachedLines;
+	return {
+		render(width) {
+			if (cachedLines !== void 0 && cachedExpanded === expanded && cachedWidth === width) return cachedLines;
+			cachedLines = formatBoxesWindowed(buildSections(), expanded ? opts.expanded : opts.collapsed, notices, width).split("\n");
+			cachedExpanded = expanded;
+			cachedWidth = width;
+			return cachedLines;
+		},
+		invalidate() {
+			cachedLines = void 0;
+			cachedExpanded = void 0;
+			cachedWidth = void 0;
+		}
+	};
+}
+/**
+* wrap visible text in an OSC 8 terminal hyperlink.
+* terminals that support OSC 8 render this as a clickable link;
+* others silently ignore the sequences and show plain text.
+*/
+function osc8Link(url, text) {
+	return `\x1b]8;;${url}\x07${text}\x1b]8;;\x07`;
+}
+/**
+* standardized call-line component for renderCall.
+* renders: bold(label) dim(context)
+*
+* usage: renderCallLine("Edit", "~/path/to/file.ts", theme)
+*/
+function renderCallLine(label, context, theme) {
+	const line = theme.fg("toolTitle", theme.bold(label)) + (context ? " " + theme.fg("dim", context) : "");
+	return {
+		render(_width) {
+			return [line];
+		},
+		invalidate() {}
+	};
+}
+if (import.meta.vitest) {
+	const { describe, it, expect } = import.meta.vitest;
+	describe("visibleWidth", () => {
+		it("counts plain text characters", () => {
+			expect(visibleWidth$1("hello")).toBe(5);
+			expect(visibleWidth$1("")).toBe(0);
+		});
+		it("expands tabs to TAB_WIDTH", () => {
+			expect(visibleWidth$1("	")).toBe(4);
+			expect(visibleWidth$1("a	b")).toBe(6);
+		});
+		it("ignores ANSI SGR sequences", () => {
+			expect(visibleWidth$1("\x1B[31mred\x1B[0m")).toBe(3);
+			expect(visibleWidth$1("\x1B[1;32mgreen\x1B[0m")).toBe(5);
+		});
+		it("ignores OSC 8 hyperlink sequences", () => {
+			expect(visibleWidth$1("\x1B]8;;https://example.com\x07link\x1B]8;;\x07")).toBe(4);
+		});
+	});
+	describe("truncateToWidth", () => {
+		it("returns text unchanged if within width", () => {
+			expect(truncateToWidth$1("hello", 10)).toBe("hello");
+		});
+		it("truncates and adds ellipsis", () => {
+			const result = truncateToWidth$1("hello world", 8);
+			expect(result).toContain("…");
+			expect(visibleWidth$1(result.replace(/\x1b\[[0-9;]*m/g, ""))).toBe(8);
+		});
+		it("preserves ANSI codes in truncated output", () => {
+			const result = truncateToWidth$1("\x1B[31mhello world\x1B[0m", 8);
+			expect(result).toContain("\x1B[31m");
+			expect(result).toContain("\x1B[0m");
+			expect(result).toContain("…");
+		});
+		it("handles text shorter than ellipsis", () => {
+			expect(truncateToWidth$1("hi", 1)).toBe("…");
+		});
+	});
+	describe("chromeWidth", () => {
+		it("returns 2 for no gutter", () => {
+			expect(chromeWidth(0)).toBe(2);
+		});
+		it("returns gutterWidth + 3 for gutter", () => {
+			expect(chromeWidth(3)).toBe(6);
+			expect(chromeWidth(5)).toBe(8);
+		});
+	});
+	describe("osc8Link", () => {
+		it("wraps text in OSC 8 hyperlink", () => {
+			expect(osc8Link("https://example.com", "click me")).toBe("\x1B]8;;https://example.com\x07click me\x1B]8;;\x07");
+		});
+		it("handles empty text", () => {
+			expect(osc8Link("https://example.com", "")).toBe("\x1B]8;;https://example.com\x07\x1B]8;;\x07");
+		});
+	});
+	describe("textSection", () => {
+		it("creates section with header and text", () => {
+			const section = textSection("Title", "line1\nline2");
+			expect(section.header).toBe("Title");
+			expect(section.blocks).toHaveLength(1);
+			expect(section.blocks[0]?.lines).toHaveLength(2);
+		});
+		it("creates headless section when header is undefined", () => {
+			expect(textSection(void 0, "content").header).toBeUndefined();
+		});
+		it("sets highlight=true by default", () => {
+			expect(textSection("Title", "text").blocks[0]?.lines[0]?.highlight).toBe(true);
+		});
+		it("sets highlight=false when dim=true", () => {
+			expect(textSection("Title", "text", true).blocks[0]?.lines[0]?.highlight).toBe(false);
+		});
+	});
+	describe("formatBoxesWindowed", () => {
+		it("renders single section with header", () => {
+			const result = formatBoxesWindowed([{
+				header: "Test",
+				blocks: [{ lines: [{ text: "hello" }] }]
+			}], {}, void 0, 80);
+			expect(result).toContain("Test");
+			expect(result).toContain("hello");
+		});
+		it("renders gutter with line numbers", () => {
+			const result = formatBoxesWindowed([{
+				header: "File",
+				blocks: [{ lines: [{
+					gutter: "1",
+					text: "first",
+					highlight: true
+				}, {
+					gutter: "2",
+					text: "second",
+					highlight: false
+				}] }]
+			}], {}, void 0, 80);
+			expect(result).toContain("1");
+			expect(result).toContain("2");
+			expect(result).toContain("first");
+			expect(result).toContain("second");
+		});
+		it("respects maxSections option", () => {
+			const result = formatBoxesWindowed([
+				{
+					header: "A",
+					blocks: [{ lines: [{ text: "a" }] }]
+				},
+				{
+					header: "B",
+					blocks: [{ lines: [{ text: "b" }] }]
+				},
+				{
+					header: "C",
+					blocks: [{ lines: [{ text: "c" }] }]
+				}
+			], { maxSections: 2 }, void 0, 80);
+			expect(result).toContain("A");
+			expect(result).toContain("B");
+			expect(result).not.toContain("C");
+			expect(result).toContain("… 1 more");
+		});
+		it("appends notices", () => {
+			expect(formatBoxesWindowed([{
+				header: "Test",
+				blocks: [{ lines: [{ text: "content" }] }]
+			}], {}, ["Notice 1", "Notice 2"], 80)).toContain("[Notice 1. Notice 2]");
+		});
+	});
+}
+//#endregion
+export { boxRendererWindowed, formatBoxesWindowed, osc8Link, renderCallLine, textSection };

package/dist/core/config.d.ts

@@ -0,0 +1,14 @@
+//#region packages/core/config/index.d.ts
+declare function setGlobalSettingsPath(p: string): void;
+declare function clearConfigCache(): void;
+interface GetExtensionConfigOpts {
+  cwd?: string;
+  allowProjectConfig?: boolean;
+}
+declare function getExtensionConfig<T extends Record<string, unknown>>(namespace: string, defaults: T, opts?: GetExtensionConfigOpts): T;
+/** read a top-level (non-namespaced) key from the global settings file. */
+declare function getGlobalConfig<T>(key: string): T | undefined;
+/** directory containing the global settings file (e.g. ~/.pi/agent/). */
+declare function resolveConfigDir(): string;
+//#endregion
+export { GetExtensionConfigOpts, clearConfigCache, getExtensionConfig, getGlobalConfig, resolveConfigDir, setGlobalSettingsPath };