@oh-my-pi/pi-coding-agent 17.0.9 → 17.1.1

package/src/utils/lang-from-path.ts

@@ -102,6 +102,9 @@ const EXTENSION_LANG: Record<string, readonly [string, string]> = {
 	md: ["markdown", "markdown"],
 	markdown: ["markdown", "markdown"],
 	mdx: ["markdown", "markdown"],
+	mdc: ["markdown", "markdown"],
+	mkd: ["markdown", "markdown"],
+	mdown: ["markdown", "markdown"],
 	rst: ["restructuredtext", "restructuredtext"],
 	adoc: ["asciidoc", "asciidoc"],
 	tex: ["latex", "latex"],
@@ -217,6 +220,10 @@ export function getLanguageFromPath(filePath: string): string | undefined {
 	return undefined;
 }
 
+export function isMarkdownPath(filePath: string): boolean {
+	return getLanguageFromPath(filePath) === "markdown";
+}
+
 /**
  * LSP language identifier; falls back to `plaintext`.
  */

package/src/utils/mac-file-urls.applescript

@@ -0,0 +1,37 @@
+-- Returns the POSIX paths of every file URL currently on the macOS
+-- pasteboard, one path per line. `pbpaste(1)` only surfaces plain text,
+-- EPS, or RTF, so a Finder Cmd+C (which puts only a `public.file-url`
+-- representation on the pasteboard) makes `pbpaste` empty. The
+-- `«class furl»` coercion reaches the file-URL representation directly and
+-- works for both single-file and multi-file selections.
+--
+-- The coercion is guarded by `clipboard info for «class furl»`: AppleScript
+-- happily coerces plain *text* into a file URL by treating it as an HFS
+-- path, so an unguarded cast turns a copied `https://i.can.ac/x.png` string
+-- into the mangled `/https/::i.can.ac:x.png` (HFS `:`↔`/` swap) and the
+-- paste dead-ends with "Image not found" instead of falling back to pasting
+-- the text. `clipboard info for` inspects the actual pasteboard types, so
+-- it is `{}` unless a real `public.file-url` representation is present.
+--
+-- The `try` blocks suppress the `-1700` "can't make … into type" error
+-- AppleScript raises when the clipboard holds no file URLs, so the script's
+-- exit status only reflects `osascript` itself.
+on run
+	set output to ""
+	try
+		if (clipboard info for «class furl») is {} then return output
+		set theClip to the clipboard as «class furl»
+		if class of theClip is list then
+			repeat with anItem in theClip
+				try
+					set output to output & POSIX path of anItem & linefeed
+				end try
+			end repeat
+		else
+			try
+				set output to POSIX path of theClip & linefeed
+			end try
+		end if
+	end try
+	return output
+end run

package/src/utils/title-generator.ts

@@ -387,7 +387,143 @@ export function setTerminalTitle(title: string): void {
 }
 
 export function setSessionTerminalTitle(sessionName: string | undefined, cwd?: string): void {
-	setTerminalTitle(formatSessionTerminalTitle(sessionName, cwd));
+	// An authoritative session title (rename, new session, focus swap) supersedes
+	// any extension override so the base title tracks the real session again.
+	terminalTitleRuntime.extensionOverride = undefined;
+	terminalTitleRuntime.label = sanitizeTerminalTitlePart(sessionName) ?? getFallbackTerminalTitle(cwd);
+	emitTerminalTitle();
+}
+
+/**
+ * Set a terminal title from an extension's `setTitle()`. Unlike the session base
+ * title, this owns the terminal verbatim: the run-state separator will not rewrite
+ * it on the next spinner tick or state change. Cleared when the app next sets an
+ * authoritative session title via {@link setSessionTerminalTitle}.
+ */
+export function setExtensionTerminalTitle(title: string): void {
+	terminalTitleRuntime.extensionOverride = title;
+	emitTerminalTitle();
+}
+
+export type TerminalTitleState = "idle" | "working" | "attention";
+
+/** Separator glyphs carrying the run state between the `π` brand and the session
+ *  label — the brand itself stays bare (no prefix glyph). Spinner frames animate
+ *  the separator while working; they are self-contained (not the theme's symbol
+ *  set) to avoid a utils→modes import cycle; OSC titles render in tab/window bars
+ *  that handle Unicode. */
+const TITLE_SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"] as const;
+const TITLE_SPINNER_INTERVAL_MS = 80;
+/** The user's turn: the title reads like a shell prompt awaiting input. */
+const TITLE_IDLE_SEPARATOR = ">";
+/** Agent blocked on the user (ask / approval prompt). */
+const TITLE_ATTENTION_SEPARATOR = "!";
+
+const terminalTitleRuntime: {
+	label: string | undefined;
+	state: TerminalTitleState;
+	frame: number;
+	enabled: boolean;
+	timer: NodeJS.Timeout | undefined;
+	lastEmitted: string | undefined;
+	/** A title an extension set via `setTitle()`. While set, it owns the terminal
+	 *  title verbatim: the run-state separator never rewrites it. Cleared when the
+	 *  app next establishes an authoritative session title (rename, new session,
+	 *  focus swap) via `setSessionTerminalTitle`. */
+	extensionOverride: string | undefined;
+} = {
+	label: undefined,
+	state: "idle",
+	frame: 0,
+	enabled: true,
+	timer: undefined,
+	lastEmitted: undefined,
+	extensionOverride: undefined,
+};
+
+/**
+ * Compose the terminal title from the `π` brand, a state-carrying SEPARATOR, and
+ * the session label. The brand never gains a prefix glyph — the separator slot
+ * expresses the run state instead. Pure (no I/O) so the state→separator contract
+ * is unit-testable:
+ *   - `idle` (user's turn):  `π > label`  — reads like a prompt awaiting input;
+ *   - `working`:             `π ⠋ label`  — spinner frames animate the separator;
+ *   - `attention`:           `π ! label`  — agent blocked on the user;
+ *   - disabled:              `π: label`   — the pre-state layout.
+ * Without a label the separator trails the brand (`π >`) so the state stays visible.
+ */
+export function buildTerminalTitleWithState(
+	label: string | undefined,
+	state: TerminalTitleState,
+	frame: number,
+	enabled: boolean,
+): string {
+	if (!enabled) return label ? `${DEFAULT_TERMINAL_TITLE}: ${label}` : DEFAULT_TERMINAL_TITLE;
+	const separator =
+		state === "working"
+			? TITLE_SPINNER_FRAMES[frame % TITLE_SPINNER_FRAMES.length]
+			: state === "attention"
+				? TITLE_ATTENTION_SEPARATOR
+				: TITLE_IDLE_SEPARATOR;
+	return label ? `${DEFAULT_TERMINAL_TITLE} ${separator} ${label}` : `${DEFAULT_TERMINAL_TITLE} ${separator}`;
+}
+
+function emitTerminalTitle(): void {
+	// An extension override owns the terminal verbatim; the run-state separator and
+	// spinner ticks must not clobber it (still deduped via lastEmitted).
+	const next =
+		terminalTitleRuntime.extensionOverride ??
+		buildTerminalTitleWithState(
+			terminalTitleRuntime.label,
+			terminalTitleRuntime.state,
+			terminalTitleRuntime.frame,
+			terminalTitleRuntime.enabled,
+		);
+	if (next === terminalTitleRuntime.lastEmitted) return;
+	terminalTitleRuntime.lastEmitted = next;
+	setTerminalTitle(next);
+}
+
+function stopTerminalTitleSpinner(): void {
+	if (terminalTitleRuntime.timer) {
+		clearInterval(terminalTitleRuntime.timer);
+		terminalTitleRuntime.timer = undefined;
+	}
+}
+
+function startTerminalTitleSpinner(): void {
+	if (terminalTitleRuntime.timer || !process.stdout.isTTY) return;
+	terminalTitleRuntime.timer = setInterval(() => {
+		terminalTitleRuntime.frame = (terminalTitleRuntime.frame + 1) % TITLE_SPINNER_FRAMES.length;
+		emitTerminalTitle();
+	}, TITLE_SPINNER_INTERVAL_MS);
+	// Never keep the event loop alive for a cosmetic animation.
+	terminalTitleRuntime.timer.unref?.();
+}
+
+/**
+ * Reflect the agent run state in the terminal title's separator: `working`
+ * animates spinner frames in the separator slot, `idle` shows `>` (your turn),
+ * `attention` shows `!` (agent blocked on you). Gated off by `tui.titleState`.
+ */
+export function setTerminalTitleState(state: TerminalTitleState): void {
+	terminalTitleRuntime.state = state;
+	if (state === "working" && terminalTitleRuntime.enabled) startTerminalTitleSpinner();
+	else stopTerminalTitleSpinner();
+	emitTerminalTitle();
+}
+
+/** Enable/disable the run-state separator (driven by the `tui.titleState` setting). */
+export function setTerminalTitleStateEnabled(enabled: boolean): void {
+	terminalTitleRuntime.enabled = enabled;
+	if (enabled && terminalTitleRuntime.state === "working") startTerminalTitleSpinner();
+	else stopTerminalTitleSpinner();
+	emitTerminalTitle();
+}
+
+/** Stop the spinner timer; call on session/UI teardown. */
+export function disposeTerminalTitleState(): void {
+	stopTerminalTitleSpinner();
 }
 
 /**

package/src/utils/tool-choice.ts

@@ -12,6 +12,19 @@ export function buildNamedToolChoice(toolName: string, model?: Model<Api>): Tool
 		return { type: "tool", name: toolName };
 	}
 
+	if (toolName === "computer" && model.supportsComputerUse === true) {
+		if (
+			model.api === "openai-codex-responses" ||
+			model.api === "openai-responses" ||
+			model.api === "azure-openai-responses"
+		) {
+			return { type: "computer" };
+		}
+		return undefined;
+	}
+	// Models without native computer support receive the tool as a regular
+	// function tool, so the generic named-function forcing below applies.
+
 	if (
 		model.api === "openai-codex-responses" ||
 		model.api === "openai-responses" ||
@@ -39,6 +52,7 @@ export function buildNamedToolChoice(toolName: string, model?: Model<Api>): Tool
  */
 export function isToolChoiceActive(toolChoice: ToolChoice | undefined, tools: readonly { name: string }[]): boolean {
 	if (!toolChoice || typeof toolChoice === "string") return true;
+	if (toolChoice.type === "computer") return tools.some(tool => tool.name === "computer");
 	const name =
 		toolChoice.type === "tool"
 			? toolChoice.name

package/src/utils/tools-manager.ts

@@ -73,16 +73,6 @@ interface ToolConfig {
 	getAssetName: (version: string, plat: string, architecture: string) => string | null;
 }
 
-// ffmpeg static-binary asset names (eugeneware/ffmpeg-static direct binaries).
-// Maps node arch (arm64|x64) only; everything else is unsupported.
-export function ffmpegAssetName(_version: string, plat: string, architecture: string): string | null {
-	if (architecture !== "arm64" && architecture !== "x64") return null;
-	if (plat === "darwin") return `ffmpeg-darwin-${architecture}`;
-	if (plat === "linux") return `ffmpeg-linux-${architecture}`;
-	if (plat === "win32") return architecture === "x64" ? "ffmpeg-win32-x64" : null;
-	return null;
-}
-
 const TOOLS: Record<string, ToolConfig> = {
 	sd: {
 		name: "sd",
@@ -139,14 +129,6 @@ const TOOLS: Record<string, ToolConfig> = {
 			return null;
 		},
 	},
-	ffmpeg: {
-		name: "ffmpeg",
-		repo: "eugeneware/ffmpeg-static",
-		binaryName: "ffmpeg",
-		tagPrefix: "",
-		isDirectBinary: true,
-		getAssetName: ffmpegAssetName,
-	},
 };
 
 // CLI packages installed via uv/pip
@@ -164,7 +146,7 @@ const PYTHON_TOOLS: Record<string, PythonPackageToolConfig> = {
 	},
 };
 
-export type ToolName = "sd" | "sg" | "yt-dlp" | "trafilatura" | "ffmpeg";
+export type ToolName = "sd" | "sg" | "yt-dlp" | "trafilatura";
 
 // Get the path to a tool (system-wide or in our tools dir)
 export function getToolPath(tool: ToolName): string | null {