@f5-sales-demo/xcsh 19.51.2

package/src/tui/code-cell.ts

@@ -0,0 +1,101 @@
+/**
+ * Render a code cell with optional output section.
+ */
+import { highlightCode, type Theme } from "../modes/theme/theme";
+import {
+	formatDuration,
+	formatExpandHint,
+	formatMoreItems,
+	formatStatusIcon,
+	replaceTabs,
+} from "../tools/render-utils";
+import { renderOutputBlock } from "./output-block";
+import type { State } from "./types";
+
+export interface CodeCellOptions {
+	code: string;
+	language?: string;
+	index?: number;
+	total?: number;
+	title?: string;
+	status?: "pending" | "running" | "complete" | "error";
+	spinnerFrame?: number;
+	duration?: number;
+	output?: string;
+	outputMaxLines?: number;
+	codeMaxLines?: number;
+	expanded?: boolean;
+	width: number;
+}
+
+function getState(status?: CodeCellOptions["status"]): State | undefined {
+	if (!status) return undefined;
+	if (status === "complete") return "success";
+	if (status === "error") return "error";
+	if (status === "running") return "running";
+	return "pending";
+}
+
+function formatHeader(options: CodeCellOptions, theme: Theme): { title: string; meta?: string } {
+	const { index, total, title, status, spinnerFrame, duration } = options;
+	const parts: string[] = [];
+	// Terminal status (complete/error) is carried by the gutter ball (xcsh#173).
+	// Only streaming states (pending/running) still render an inline indicator.
+	if (status === "pending" || status === "running") {
+		const icon = formatStatusIcon(status, theme, spinnerFrame);
+		parts.push(`${icon} ${theme.fg("muted", status)}`);
+	}
+	if (index !== undefined && total !== undefined) {
+		parts.push(theme.fg("contentAccent", `[${index + 1}/${total}]`));
+	}
+	if (title) {
+		parts.push(theme.fg("toolTitle", title));
+	}
+	const headerTitle = parts.length > 0 ? parts.join(" ") : theme.fg("toolTitle", "Code");
+
+	const metaParts: string[] = [];
+	if (duration !== undefined) {
+		metaParts.push(theme.fg("dim", `(${formatDuration(duration)})`));
+	}
+	if (metaParts.length === 0) return { title: headerTitle };
+	return { title: headerTitle, meta: metaParts.join(theme.fg("dim", theme.sep.dot)) };
+}
+
+export function renderCodeCell(options: CodeCellOptions, theme: Theme): string[] {
+	const { code, language, output, expanded = false, outputMaxLines = 6, codeMaxLines = 12, width } = options;
+	const { title, meta } = formatHeader(options, theme);
+	const state = getState(options.status);
+
+	const rawCodeLines = highlightCode(replaceTabs(code ?? ""), language);
+	const maxCodeLines = expanded ? rawCodeLines.length : Math.min(rawCodeLines.length, codeMaxLines);
+	const codeLines = rawCodeLines.slice(0, maxCodeLines);
+	const hiddenCodeLines = rawCodeLines.length - codeLines.length;
+	if (hiddenCodeLines > 0) {
+		const hint = formatExpandHint(theme, expanded, hiddenCodeLines > 0);
+		const moreLine = `${formatMoreItems(hiddenCodeLines, "line")}${hint ? ` ${hint}` : ""}`;
+		codeLines.push(theme.fg("dim", moreLine));
+	}
+
+	const outputLines: string[] = [];
+	if (output?.trim()) {
+		const rawLines = output.split("\n");
+		const maxLines = expanded ? rawLines.length : Math.min(rawLines.length, outputMaxLines);
+		const displayLines = rawLines
+			.slice(0, maxLines)
+			.map(line => (line.includes("\x1b[") ? replaceTabs(line) : theme.fg("toolOutput", replaceTabs(line))));
+		outputLines.push(...displayLines);
+		const remaining = rawLines.length - maxLines;
+		if (remaining > 0) {
+			const hint = formatExpandHint(theme, expanded, remaining > 0);
+			const moreLine = `${formatMoreItems(remaining, "line")}${hint ? ` ${hint}` : ""}`;
+			outputLines.push(theme.fg("dim", moreLine));
+		}
+	}
+
+	const sections: Array<{ label?: string; lines: string[] }> = [{ lines: codeLines }];
+	if (outputLines.length > 0) {
+		sections.push({ label: theme.fg("toolTitle", "Output"), lines: outputLines });
+	}
+
+	return renderOutputBlock({ header: title, headerMeta: meta, state, sections, width }, theme);
+}

package/src/tui/file-list.ts

@@ -0,0 +1,47 @@
+/**
+ * Render file listings with optional icons and metadata.
+ */
+import type { Theme } from "../modes/theme/theme";
+import { getLanguageFromPath } from "../modes/theme/theme";
+import { renderTreeList } from "./tree-list";
+
+export interface FileEntry {
+	path: string;
+	isDirectory?: boolean;
+	meta?: string;
+}
+
+export interface FileListOptions {
+	files: FileEntry[];
+	expanded?: boolean;
+	maxCollapsed?: number;
+	showIcons?: boolean;
+}
+
+export function renderFileList(options: FileListOptions, theme: Theme): string[] {
+	const { files, expanded = false, maxCollapsed = 8, showIcons = true } = options;
+
+	return renderTreeList(
+		{
+			items: files,
+			expanded,
+			maxCollapsed,
+			itemType: "file",
+			renderItem: entry => {
+				const isDirectory = entry.isDirectory ?? entry.path.endsWith("/");
+				const displayPath = isDirectory && entry.path.endsWith("/") ? entry.path : entry.path;
+				const lang = isDirectory ? undefined : getLanguageFromPath(displayPath);
+				const icon = !showIcons
+					? ""
+					: isDirectory
+						? theme.fg("contentAccent", theme.icon.folder)
+						: theme.fg("muted", theme.getLangIcon(lang));
+				const labelColor = isDirectory ? "contentAccent" : "toolOutput";
+				const meta = entry.meta ? ` ${theme.fg("dim", entry.meta)}` : "";
+				const iconPrefix = icon ? `${icon} ` : "";
+				return `${iconPrefix}${theme.fg(labelColor, displayPath)}${meta}`;
+			},
+		},
+		theme,
+	);
+}

package/src/tui/index.ts

@@ -0,0 +1,11 @@
+/**
+ * Public exports for shared TUI components.
+ */
+
+export * from "./code-cell";
+export * from "./file-list";
+export * from "./output-block";
+export * from "./status-line";
+export * from "./tree-list";
+export * from "./types";
+export * from "./utils";

package/src/tui/output-block.ts

@@ -0,0 +1,175 @@
+/**
+ * Bordered output container with optional header and sections.
+ */
+import { ImageProtocol, padding, TERMINAL, visibleWidth, wrapTextWithAnsi } from "@f5xc-salesdemos/pi-tui";
+import type { Theme, ThemeColor } from "../modes/theme/theme";
+import { getImageLineMask } from "../utils/image-passthrough";
+import type { State } from "./types";
+import type { RenderCache } from "./utils";
+import { Ellipsis, getStateBgColor, Hasher, padToWidth, truncateToWidth } from "./utils";
+
+/**
+ * Border color override for F5-branded tool renderers.
+ * Pass as `borderColor` in OutputBlockOptions to apply F5 red framing regardless of tool state.
+ */
+export const F5_TOOL_BORDER_COLOR: ThemeColor = "border";
+
+export interface OutputBlockOptions {
+	header?: string;
+	headerMeta?: string;
+	state?: State;
+	sections?: Array<{ label?: string; lines: string[] }>;
+	width: number;
+	applyBg?: boolean;
+	/** Override the state-derived border color. Always takes precedence, including on error. Use for branded core tools. */
+	borderColor?: ThemeColor;
+	/**
+	 * Word-wrap content lines to fit the inner width (default). Set false to CLIP
+	 * (truncate) instead — required for pre-formatted grid content like mermaid
+	 * diagrams, where wrapping reflows characters and destroys alignment.
+	 */
+	wrapContent?: boolean;
+}
+
+export function renderOutputBlock(options: OutputBlockOptions, theme: Theme): string[] {
+	const {
+		header,
+		headerMeta,
+		state,
+		sections = [],
+		width,
+		applyBg = true,
+		borderColor: borderColorOverride,
+		wrapContent = true,
+	} = options;
+	const h = theme.boxSharp.horizontal;
+	const v = theme.boxSharp.vertical;
+	const cap = h.repeat(3);
+	const lineWidth = Math.max(0, width);
+	// borderColorOverride (F5 brand chrome) always takes precedence;
+	// built-in tools without an override use dim borders regardless of error state.
+	const resolvedBorderColor: ThemeColor =
+		borderColorOverride ??
+		(state === "warning" ? "warning" : state === "running" || state === "pending" ? "spinnerAccent" : "dim");
+	const border = (text: string) => theme.fg(resolvedBorderColor, text);
+	const bgFn = (() => {
+		if (!state || !applyBg) return undefined;
+		const bgAnsi = theme.getBgAnsi(getStateBgColor(state));
+		// Keep block background stable even if inner content contains SGR resets (e.g. "\x1b[0m"),
+		// which would otherwise clear the outer background mid-line.
+		return (text: string) => {
+			const stabilized = text
+				.replace(/\x1b\[(?:0)?m/g, m => `${m}${bgAnsi}`)
+				.replace(/\x1b\[49m/g, m => `${m}${bgAnsi}`);
+			return `${bgAnsi}${stabilized}\x1b[49m`;
+		};
+	})();
+
+	const buildBarLine = (leftChar: string, rightChar: string, label?: string, meta?: string): string => {
+		const left = border(`${leftChar}${cap}`);
+		const right = border(rightChar);
+		if (lineWidth <= 0) return left + right;
+		const labelText = [label, meta].filter(Boolean).join(theme.sep.dot);
+		const rawLabel = labelText ? ` ${labelText} ` : " ";
+		const leftWidth = visibleWidth(left);
+		const rightWidth = visibleWidth(right);
+		const maxLabelWidth = Math.max(0, lineWidth - leftWidth - rightWidth);
+		const trimmedLabel = truncateToWidth(rawLabel, maxLabelWidth);
+		const labelWidth = visibleWidth(trimmedLabel);
+		const fillCount = Math.max(0, lineWidth - leftWidth - labelWidth - rightWidth);
+		return `${left}${trimmedLabel}${border(h.repeat(fillCount))}${right}`;
+	};
+
+	const contentPrefix = border(`${v} `);
+	const contentSuffix = border(v);
+	const contentWidth = Math.max(0, lineWidth - visibleWidth(contentPrefix) - visibleWidth(contentSuffix));
+	const lines: string[] = [];
+
+	lines.push(
+		padToWidth(buildBarLine(theme.boxSharp.topLeft, theme.boxSharp.topRight, header, headerMeta), lineWidth, bgFn),
+	);
+
+	const hasSections = sections.length > 0;
+	const normalizedSections = hasSections ? sections : [{ lines: [] }];
+
+	for (let i = 0; i < normalizedSections.length; i++) {
+		const section = normalizedSections[i];
+		if (section.label) {
+			lines.push(
+				padToWidth(buildBarLine(theme.boxSharp.teeRight, theme.boxSharp.teeLeft, section.label), lineWidth, bgFn),
+			);
+		}
+		const allLines = section.lines.flatMap(l => l.split("\n"));
+		const sixelLineMask = TERMINAL.imageProtocol === ImageProtocol.Sixel ? getImageLineMask(allLines) : undefined;
+		for (let lineIndex = 0; lineIndex < allLines.length; lineIndex++) {
+			const line = allLines[lineIndex]!;
+			if (sixelLineMask?.[lineIndex]) {
+				lines.push(line);
+				continue;
+			}
+			const wrappedLines = wrapContent
+				? wrapTextWithAnsi(line.trimEnd(), contentWidth)
+				: // Clip cleanly with no trailing ellipsis — a column of "…" down the
+					// right edge of a clipped diagram is clutter, not information.
+					[truncateToWidth(line.trimEnd(), contentWidth, Ellipsis.Omit)];
+			for (const wrappedLine of wrappedLines) {
+				const innerPadding = padding(Math.max(0, contentWidth - visibleWidth(wrappedLine)));
+				const fullLine = `${contentPrefix}${wrappedLine}${innerPadding}${contentSuffix}`;
+				lines.push(padToWidth(fullLine, lineWidth, bgFn));
+			}
+		}
+	}
+
+	const bottomLeft = border(`${theme.boxSharp.bottomLeft}${cap}`);
+	const bottomRight = border(theme.boxSharp.bottomRight);
+	const bottomFillCount = Math.max(0, lineWidth - visibleWidth(bottomLeft) - visibleWidth(bottomRight));
+	const bottomLine = `${bottomLeft}${border(h.repeat(bottomFillCount))}${bottomRight}`;
+	lines.push(padToWidth(bottomLine, lineWidth, bgFn));
+
+	return lines;
+}
+
+/**
+ * Cached wrapper around `renderOutputBlock`.
+ *
+ * Since output blocks are re-rendered on every frame (via `render(width)` closures),
+ * but their content rarely changes, this cache avoids redundant `visibleWidth()` and
+ * `padding()` computations on ~99% of render calls.
+ */
+export class CachedOutputBlock {
+	#cache?: RenderCache;
+
+	/** Render with caching. Returns cached result if options haven't changed. */
+	render(options: OutputBlockOptions, theme: Theme): string[] {
+		const key = this.#buildKey(options);
+		if (this.#cache?.key === key) return this.#cache.lines;
+		const lines = renderOutputBlock(options, theme);
+		this.#cache = { key, lines };
+		return lines;
+	}
+
+	/** Invalidate the cache, forcing a rebuild on next render. */
+	invalidate(): void {
+		this.#cache = undefined;
+	}
+
+	#buildKey(options: OutputBlockOptions): bigint {
+		const h = new Hasher();
+		h.u32(options.width);
+		h.optional(options.header);
+		h.optional(options.headerMeta);
+		h.optional(options.state);
+		h.bool(options.applyBg ?? true);
+		h.optional(options.borderColor);
+		h.bool(options.wrapContent ?? true);
+		if (options.sections) {
+			for (const s of options.sections) {
+				h.optional(s.label);
+				for (const line of s.lines) {
+					h.str(line);
+				}
+			}
+		}
+		return h.digest();
+	}
+}

package/src/tui/status-line.ts

@@ -0,0 +1,39 @@
+/**
+ * Standardized status header rendering for tool output.
+ */
+import type { Theme, ThemeColor } from "../modes/theme/theme";
+import type { ToolUIStatus } from "../tools/render-utils";
+import { formatStatusIcon } from "../tools/render-utils";
+
+export interface StatusLineOptions {
+	icon?: ToolUIStatus;
+	spinnerFrame?: number;
+	title: string;
+	titleColor?: ThemeColor;
+	description?: string;
+	badge?: { label: string; color: ThemeColor };
+	meta?: string[];
+}
+
+export function renderStatusLine(options: StatusLineOptions, theme: Theme): string {
+	const icon = options.icon ? formatStatusIcon(options.icon, theme, options.spinnerFrame) : "";
+	const titleColor = options.titleColor ?? "contentAccent";
+	const title = theme.fg(titleColor, options.title);
+	let line = icon ? `${icon} ${title}` : title;
+
+	if (options.description) {
+		line += `: ${theme.fg("muted", options.description)}`;
+	}
+
+	if (options.badge) {
+		const { label, color } = options.badge;
+		line += ` ${theme.fg(color, `${theme.format.bracketLeft}${label}${theme.format.bracketRight}`)}`;
+	}
+
+	const meta = options.meta?.filter(value => value.trim().length > 0) ?? [];
+	if (meta.length > 0) {
+		line += ` ${theme.fg("dim", meta.join(theme.sep.dot))}`;
+	}
+
+	return line;
+}

package/src/tui/tree-list.ts

@@ -0,0 +1,84 @@
+/**
+ * Hierarchical tree list rendering helper.
+ */
+
+import { replaceTabs } from "@f5xc-salesdemos/pi-tui";
+import type { Theme } from "../modes/theme/theme";
+import { formatMoreItems } from "../tools/render-utils";
+import type { TreeContext } from "./types";
+import { getTreeBranch, getTreeContinuePrefix } from "./utils";
+
+export interface TreeListOptions<T> {
+	items: T[];
+	expanded?: boolean;
+	maxCollapsed?: number;
+	/** Strict total-line budget for collapsed mode. When set (and not expanded),
+	 *  rendered item lines plus the trailing summary line must fit within this budget.
+	 */
+	maxCollapsedLines?: number;
+	itemType?: string;
+	/** Called once per item with `isLast: false` during budget calculation;
+	 *  line count MUST NOT vary based on `isLast`. */
+	renderItem: (item: T, context: TreeContext) => string | string[];
+}
+
+export function renderTreeList<T>(options: TreeListOptions<T>, theme: Theme): string[] {
+	const { items, expanded = false, maxCollapsed = 8, maxCollapsedLines, itemType = "item", renderItem } = options;
+	const maxItems = expanded ? items.length : Math.min(items.length, maxCollapsed);
+	const linesBudget = !expanded && maxCollapsedLines !== undefined ? maxCollapsedLines : Infinity;
+
+	// Pre-render each candidate item once.
+	// isLast cannot be known at this point (fittingCount is not yet determined);
+	// renderItem implementations MUST NOT vary line count based on isLast.
+	const preRendered: string[][] = [];
+	for (let i = 0; i < maxItems; i++) {
+		const rendered = renderItem(items[i], {
+			index: i,
+			isLast: false,
+			depth: 0,
+			theme,
+			prefix: "",
+			continuePrefix: "",
+		});
+		preRendered.push(Array.isArray(rendered) ? rendered : rendered ? [rendered] : []);
+	}
+
+	// Determine how many items fit within the line budget.
+	let fittingCount = maxItems;
+	let fittedLineCount = 0;
+	if (linesBudget !== Infinity) {
+		fittingCount = 0;
+		for (let i = 0; i < maxItems; i++) {
+			const count = preRendered[i]!.length;
+			const remainingAfter = items.length - (i + 1);
+			const reservedSummaryLines = remainingAfter > 0 ? 1 : 0;
+			if (fittedLineCount + count + reservedSummaryLines > linesBudget) break;
+			fittedLineCount += count;
+			fittingCount = i + 1;
+		}
+	}
+
+	const remaining = items.length - fittingCount;
+	const hasSummary = !expanded && remaining > 0 && (linesBudget === Infinity || fittedLineCount < linesBudget);
+
+	// Emit pre-rendered content with correct isLast-based branch prefixes.
+	const lines: string[] = [];
+	for (let i = 0; i < fittingCount; i++) {
+		const isLast = !hasSummary && i === fittingCount - 1;
+		const branch = getTreeBranch(isLast, theme);
+		const prefix = `${theme.fg("dim", branch)} `;
+		const continuePrefix = `${theme.fg("dim", getTreeContinuePrefix(isLast, theme))}`;
+		const itemLines = preRendered[i]!;
+		if (itemLines.length === 0) continue;
+		lines.push(`${prefix}${replaceTabs(itemLines[0]!)}`);
+		for (let j = 1; j < itemLines.length; j++) {
+			lines.push(`${continuePrefix}${replaceTabs(itemLines[j]!)}`);
+		}
+	}
+
+	if (hasSummary) {
+		lines.push(`${theme.fg("dim", theme.tree.last)} ${theme.fg("muted", formatMoreItems(remaining, itemType))}`);
+	}
+
+	return lines;
+}

package/src/tui/types.ts

@@ -0,0 +1,15 @@
+/**
+ * Shared types for TUI rendering components.
+ */
+import type { Theme } from "../modes/theme/theme";
+
+export type State = "pending" | "running" | "success" | "error" | "warning";
+
+export interface TreeContext {
+	index: number;
+	isLast: boolean;
+	depth: number;
+	theme: Theme;
+	prefix: string;
+	continuePrefix: string;
+}

package/src/tui/utils.ts

@@ -0,0 +1,103 @@
+/**
+ * Shared helpers for tool-rendered UI components.
+ */
+import { padding, visibleWidth } from "@f5xc-salesdemos/pi-tui";
+import type { Theme, ThemeBg } from "../modes/theme/theme";
+import type { State } from "./types";
+
+export { Ellipsis, truncateToWidth } from "@f5xc-salesdemos/pi-tui";
+
+/** Cached typed-array scratch space for hashing non-string primitives. */
+const hashBuf = new ArrayBuffer(8);
+const hashView = new DataView(hashBuf);
+const hashBytes1 = new Uint8Array(hashBuf, 0, 1);
+const hashBytes4 = new Uint8Array(hashBuf, 0, 4);
+const hashBytes8 = new Uint8Array(hashBuf, 0, 8);
+
+/**
+ * Incremental xxHash64 key builder.
+ *
+ * Chains `Bun.hash.xxHash64` calls via seeding — each fed value
+ * mixes into the running hash without intermediate string allocations.
+ * Accepts strings, numbers (u32), booleans, bigints, and `undefined`/`null`
+ * (hashed as a sentinel byte) natively.
+ */
+export class Hasher {
+	#h = 0n;
+
+	/** Feed a string. */
+	str(s: string): this {
+		hashView.setUint32(0, s.length);
+		this.#h = Bun.hash.xxHash64(hashBytes4, this.#h);
+		this.#h = Bun.hash.xxHash64(s, this.#h);
+		return this;
+	}
+
+	/** Feed an unsigned 32-bit integer. */
+	u32(n: number): this {
+		hashView.setUint32(0, n);
+		this.#h = Bun.hash.xxHash64(hashBytes4, this.#h);
+		return this;
+	}
+
+	/** Feed a 64-bit bigint. */
+	u64(n: bigint): this {
+		hashView.setBigUint64(0, n);
+		this.#h = Bun.hash.xxHash64(hashBytes8, this.#h);
+		return this;
+	}
+
+	/** Feed a boolean (single byte: 1 = true, 0 = false). */
+	bool(b: boolean): this {
+		hashView.setUint8(0, b ? 1 : 0);
+		this.#h = Bun.hash.xxHash64(hashBytes1, this.#h);
+		return this;
+	}
+
+	/** Feed a value that may be `undefined` or `null` (hashed as a 0xFF sentinel byte). */
+	optional(v: string | undefined | null): this {
+		if (v == null) {
+			hashView.setUint8(0, 0xff);
+			this.#h = Bun.hash.xxHash64(hashBytes1, this.#h);
+		} else {
+			this.#h = Bun.hash.xxHash64(v, this.#h);
+		}
+		return this;
+	}
+
+	/** Return the final hash digest. */
+	digest(): bigint {
+		return this.#h;
+	}
+}
+
+/** Render-cache entry used by tool renderers. */
+export interface RenderCache {
+	key: bigint;
+	lines: string[];
+}
+
+export function buildTreePrefix(ancestors: boolean[], theme: Theme): string {
+	return ancestors.map(hasNext => (hasNext ? `${theme.tree.vertical}  ` : "   ")).join("");
+}
+
+export function getTreeBranch(isLast: boolean, theme: Theme): string {
+	return isLast ? theme.tree.last : theme.tree.branch;
+}
+
+export function getTreeContinuePrefix(isLast: boolean, theme: Theme): string {
+	return isLast ? "   " : `${theme.tree.vertical}  `;
+}
+
+export function padToWidth(text: string, width: number, bgFn?: (s: string) => string): string {
+	if (width <= 0) return bgFn ? bgFn(text) : text;
+	const paddingNeeded = Math.max(0, width - visibleWidth(text));
+	const padded = paddingNeeded > 0 ? text + padding(paddingNeeded) : text;
+	return bgFn ? bgFn(padded) : padded;
+}
+
+export function getStateBgColor(state: State): ThemeBg {
+	if (state === "success") return "toolSuccessBg";
+	if (state === "error") return "toolErrorBg";
+	return "toolPendingBg";
+}

package/src/utils/changelog.ts

@@ -0,0 +1,98 @@
+import { isEnoent, logger } from "@f5xc-salesdemos/pi-utils";
+
+export interface ChangelogEntry {
+	major: number;
+	minor: number;
+	patch: number;
+	content: string;
+}
+
+/**
+ * Parse changelog entries from CHANGELOG.md
+ * Scans for ## lines and collects content until next ## or EOF
+ */
+export async function parseChangelog(changelogPath: string): Promise<ChangelogEntry[]> {
+	try {
+		const content = await Bun.file(changelogPath).text();
+		const lines = content.split("\n");
+		const entries: ChangelogEntry[] = [];
+
+		let currentLines: string[] = [];
+		let currentVersion: { major: number; minor: number; patch: number } | null = null;
+
+		for (const line of lines) {
+			// Check if this is a version header (## [x.y.z] ...)
+			if (line.startsWith("## ")) {
+				// Save previous entry if exists
+				if (currentVersion && currentLines.length > 0) {
+					entries.push({
+						...currentVersion,
+						content: currentLines.join("\n").trim(),
+					});
+				}
+
+				// Try to parse version from this line
+				const versionMatch = line.match(/##\s+\[?(\d+)\.(\d+)\.(\d+)\]?/);
+				if (versionMatch) {
+					currentVersion = {
+						major: Number.parseInt(versionMatch[1], 10),
+						minor: Number.parseInt(versionMatch[2], 10),
+						patch: Number.parseInt(versionMatch[3], 10),
+					};
+					currentLines = [line];
+				} else {
+					// Reset if we can't parse version
+					currentVersion = null;
+					currentLines = [];
+				}
+			} else if (currentVersion) {
+				// Collect lines for current version
+				currentLines.push(line);
+			}
+		}
+
+		// Save last entry
+		if (currentVersion && currentLines.length > 0) {
+			entries.push({
+				...currentVersion,
+				content: currentLines.join("\n").trim(),
+			});
+		}
+
+		return entries;
+	} catch (error) {
+		if (isEnoent(error)) {
+			return [];
+		}
+		logger.error(`Warning: Could not parse changelog: ${error}`);
+		return [];
+	}
+}
+
+/**
+ * Compare versions. Returns: -1 if v1 < v2, 0 if v1 === v2, 1 if v1 > v2
+ */
+export function compareVersions(v1: ChangelogEntry, v2: ChangelogEntry): number {
+	if (v1.major !== v2.major) return v1.major - v2.major;
+	if (v1.minor !== v2.minor) return v1.minor - v2.minor;
+	return v1.patch - v2.patch;
+}
+
+/**
+ * Get entries newer than lastVersion
+ */
+export function getNewEntries(entries: ChangelogEntry[], lastVersion: string): ChangelogEntry[] {
+	// Parse lastVersion
+	const parts = lastVersion.split(".").map(Number);
+	const last: ChangelogEntry = {
+		major: parts[0] || 0,
+		minor: parts[1] || 0,
+		patch: parts[2] || 0,
+		content: "",
+	};
+
+	return entries.filter(entry => compareVersions(entry, last) > 0);
+}
+
+// Re-export getChangelogPath from paths.ts for convenience
+export { getChangelogPath } from "../config";