@oh-my-pi/pi-coding-agent 16.4.2 → 16.4.3

package/src/utils/changelog.ts

@@ -7,6 +7,27 @@ export interface ChangelogEntry {
 	content: string;
 }
 
+/** Number of changelog releases shown by automatic and default recent views. */
+export const RECENT_CHANGELOG_ENTRY_LIMIT = 3;
+/** Maximum Markdown source bytes allowed in automatic startup release notes. */
+export const STARTUP_CHANGELOG_MAX_BYTES = 64 * 1024;
+/** Hint appended when automatic startup release notes are truncated. */
+export const STARTUP_CHANGELOG_FULL_HINT = "Use `/changelog full` to view the complete changelog.";
+
+/** Markdown generated from selected changelog entries and whether it hit a size cap. */
+export interface RenderedChangelog {
+	markdown: string;
+	truncated: boolean;
+}
+
+/** Automatic startup changelog decision, including whether the marker should advance. */
+export interface StartupChangelogSelection {
+	markdown: string | undefined;
+	persistCurrentVersion: boolean;
+	truncated: boolean;
+	selectedEntries: number;
+}
+
 /**
  * Parse changelog entries from the file at `changelogPath`. Scans for `## [x.y.z]`
  * headings and collects each block until the next heading or EOF.
@@ -87,19 +108,95 @@ export function compareVersions(v1: ChangelogEntry, v2: ChangelogEntry): number
 }
 
 /**
- * Get entries newer than lastVersion
+ * Parse an omp changelog marker version into comparable parts.
  */
-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,
+export function parseChangelogVersion(version: string | undefined): ChangelogEntry | undefined {
+	const match = version?.match(/^(\d+)\.(\d+)\.(\d+)$/);
+	if (!match) {
+		return undefined;
+	}
+
+	return {
+		major: Number.parseInt(match[1], 10),
+		minor: Number.parseInt(match[2], 10),
+		patch: Number.parseInt(match[3], 10),
 		content: "",
 	};
+}
+
+/**
+ * Get entries newer than lastVersion.
+ */
+export function getNewEntries(entries: ChangelogEntry[], lastVersion: string): ChangelogEntry[] {
+	const parsedLastVersion = parseChangelogVersion(lastVersion);
+	if (!parsedLastVersion) {
+		return [];
+	}
+
+	return entries.filter(entry => compareVersions(entry, parsedLastVersion) > 0);
+}
 
-	return entries.filter(entry => compareVersions(entry, last) > 0);
+/**
+ * Render changelog entries oldest-first by default and optionally cap the Markdown source size.
+ */
+export function renderChangelogEntries(
+	entries: ChangelogEntry[],
+	options: { maxBytes?: number; truncationHint?: string; oldestFirst?: boolean } = {},
+): RenderedChangelog {
+	const orderedEntries = options.oldestFirst === false ? entries : [...entries].reverse();
+	const markdown = orderedEntries.map(entry => entry.content).join("\n\n");
+	if (options.maxBytes === undefined || Buffer.byteLength(markdown) <= options.maxBytes) {
+		return { markdown, truncated: false };
+	}
+
+	const suffix = `\n\n…\n\n${options.truncationHint ?? STARTUP_CHANGELOG_FULL_HINT}`;
+	let low = 0;
+	let high = markdown.length;
+	while (low < high) {
+		const middle = Math.floor((low + high + 1) / 2);
+		if (Buffer.byteLength(markdown.slice(0, middle) + suffix) <= options.maxBytes) {
+			low = middle;
+		} else {
+			high = middle - 1;
+		}
+	}
+
+	return { markdown: markdown.slice(0, low) + suffix, truncated: true };
+}
+
+/**
+ * Select bounded release notes for interactive startup.
+ */
+export function selectStartupChangelog(
+	entries: ChangelogEntry[],
+	lastVersion: string | undefined,
+	currentVersion: string,
+): StartupChangelogSelection {
+	const parsedLastVersion = parseChangelogVersion(lastVersion);
+	if (!parsedLastVersion) {
+		return { markdown: undefined, persistCurrentVersion: true, truncated: false, selectedEntries: 0 };
+	}
+	const markerVersion = lastVersion ?? "";
+	if (markerVersion === currentVersion) {
+		return { markdown: undefined, persistCurrentVersion: false, truncated: false, selectedEntries: 0 };
+	}
+
+	const newEntries = getNewEntries(entries, markerVersion).slice(0, RECENT_CHANGELOG_ENTRY_LIMIT);
+	if (newEntries.length === 0) {
+		return { markdown: undefined, persistCurrentVersion: false, truncated: false, selectedEntries: 0 };
+	}
+
+	const rendered = renderChangelogEntries(newEntries, {
+		maxBytes: STARTUP_CHANGELOG_MAX_BYTES,
+		truncationHint: STARTUP_CHANGELOG_FULL_HINT,
+		oldestFirst: false,
+	});
+	return {
+		markdown: rendered.markdown,
+		persistCurrentVersion: true,
+		truncated: rendered.truncated,
+		selectedEntries: newEntries.length,
+	};
 }
 
 // Re-export getChangelogPath from paths.ts for convenience

package/src/utils/git.ts

@@ -197,7 +197,6 @@ const GIT_NON_INTERACTIVE_ENV = {
 	GIT_ASKPASS: "true",
 	GIT_EDITOR: "true",
 	GIT_TERMINAL_PROMPT: "0",
-	GPG_TTY: "not a tty",
 	SSH_ASKPASS: "/usr/bin/false",
 } satisfies Record<string, string>;
 const GH_NON_INTERACTIVE_ENV = {

package/src/utils/title-generator.ts

@@ -4,6 +4,7 @@
 import * as path from "node:path";
 
 import { type Api, type AssistantMessage, completeSimple, type Model } from "@oh-my-pi/pi-ai";
+import { StreamMarkupHealing } from "@oh-my-pi/pi-ai/utils/stream-markup-healing";
 import { isTerminalHeadless, logger, prompt } from "@oh-my-pi/pi-utils";
 import type { ModelRegistry } from "../config/model-registry";
 
@@ -32,7 +33,12 @@ const TERMINAL_TITLE_CONTROL_CHARS = /[\u0000-\u001f\u007f-\u009f]/g;
 const TITLE_MAX_TOKENS = 1024;
 
 /** Matches the title the model wraps in `<title>...</title>`. */
-const TITLE_MARKER_RE = /<title>([\s\S]*?)<\/title>/i;
+const TITLE_MARKER_GLOBAL_RE = /<title>([\s\S]*?)<\/title>/gi;
+const TITLE_VISIBILITY_SENTINEL = "\uE000omp-title-visible\uE000";
+const THINKING_TAG_ENVELOPE_RE = /<(think|thinking|reasoning)>\s*[\s\S]*?<\/\1>/gi;
+const THINKING_FENCE_ENVELOPE_RE = /```(?:thinking|reasoning)\b[\s\S]*?```/gi;
+const LEADING_THINKING_TAG_RE = /^\s*<(think|thinking|reasoning)>\s*[\s\S]*?<\/\1>\s*/i;
+const LEADING_THINKING_FENCE_RE = /^\s*```(?:thinking|reasoning)\b[\s\S]*?```\s*/i;
 
 function getTitleModel(registry: ModelRegistry, settings: Settings, currentModel?: Model<Api>): Model<Api> | undefined {
 	const availableModels = registry.getAvailable();
@@ -241,12 +247,69 @@ function extractGeneratedTitle(contentBlocks: AssistantMessage["content"]): stri
 			textTitle += content.text;
 		}
 	}
-	// Stay lenient: prefer the marker when the model closed it, otherwise
-	// accept a plain sentence after stripping any stray/unclosed tag fragment
-	// (e.g. output truncated before the closing tag).
-	const marker = TITLE_MARKER_RE.exec(textTitle);
-	const candidate = marker ? marker[1].trim() : textTitle.replace(/<\/?title>/gi, "").trim();
-	return unwrapJsonTitle(candidate);
+	// Stay lenient: prefer the first closed title marker in visible text, then
+	// fall back to a plain sentence after stripping only known leading leaked
+	// thinking envelopes plus any stray/unclosed title tag fragment.
+	const markedTitle = extractVisibleMarkedTitle(textTitle);
+	const cleanedTextTitle =
+		markedTitle ??
+		stripLeadingLeakedThinkingMarkup(textTitle)
+			.replace(/<\/?title>/gi, "")
+			.trim();
+	return unwrapJsonTitle(cleanedTextTitle);
+}
+
+function extractVisibleMarkedTitle(text: string): string | undefined {
+	TITLE_MARKER_GLOBAL_RE.lastIndex = 0;
+	let marker: RegExpExecArray | null = TITLE_MARKER_GLOBAL_RE.exec(text);
+	while (marker !== null) {
+		const title = marker[1];
+		if (title !== undefined && isVisibleTitleMarker(text, marker.index)) return title.trim();
+		marker = TITLE_MARKER_GLOBAL_RE.exec(text);
+	}
+	return undefined;
+}
+
+function isVisibleTitleMarker(text: string, markerIndex: number): boolean {
+	if (isInsideKnownThinkingEnvelope(text, markerIndex)) return false;
+	return stripLeakedThinkingMarkup(`${text.slice(0, markerIndex)}${TITLE_VISIBILITY_SENTINEL}`).endsWith(
+		TITLE_VISIBILITY_SENTINEL,
+	);
+}
+
+function isInsideKnownThinkingEnvelope(text: string, index: number): boolean {
+	return (
+		isInsideEnvelopeMatchedBy(THINKING_TAG_ENVELOPE_RE, text, index) ||
+		isInsideEnvelopeMatchedBy(THINKING_FENCE_ENVELOPE_RE, text, index)
+	);
+}
+
+function isInsideEnvelopeMatchedBy(pattern: RegExp, text: string, index: number): boolean {
+	pattern.lastIndex = 0;
+	let marker = pattern.exec(text);
+	while (marker !== null) {
+		const start = marker.index;
+		const end = start + marker[0].length;
+		if (index > start && index < end) return true;
+		if (start > index) return false;
+		marker = pattern.exec(text);
+	}
+	return false;
+}
+
+function stripLeadingLeakedThinkingMarkup(text: string): string {
+	let current = text;
+	while (true) {
+		const withoutTag = current.replace(LEADING_THINKING_TAG_RE, "");
+		const withoutFence = withoutTag.replace(LEADING_THINKING_FENCE_RE, "");
+		if (withoutFence === current) return current;
+		current = withoutFence;
+	}
+}
+
+function stripLeakedThinkingMarkup(text: string): string {
+	const healer = new StreamMarkupHealing({ pattern: "thinking" });
+	return healer.feed(text) + healer.flushPending();
 }
 
 /**