@oh-my-pi/pi-coding-agent 17.0.8 → 17.1.0

package/src/utils/jj.ts

@@ -1,4 +1,4 @@
-import * as fs from "node:fs/promises";
+import * as fs from "node:fs";
 import * as path from "node:path";
 import { $which } from "@oh-my-pi/pi-utils";
 import { LRUCache } from "lru-cache/raw";
@@ -63,6 +63,8 @@ export class JjCommandError extends Error {
 // ════════════════════════════════════════════════════════════════════════════
 // Internal: Core execution
 // ════════════════════════════════════════════════════════════════════════════
+const WORKING_COPY_LABEL_REVSET = "@ | heads(::@ & bookmarks())";
+const WORKING_COPY_LABEL_TEMPLATE = 'change_id.shortest(8) ++ "|" ++ local_bookmarks ++ "\\n"';
 
 function ensureAvailable(): void {
 	if (!$which("jj")) {
@@ -121,6 +123,19 @@ async function runText(cwd: string, args: readonly string[], options: CommandOpt
 	return (await runChecked(cwd, args, options)).stdout;
 }
 
+async function runOptionalText(
+	cwd: string,
+	args: readonly string[],
+	options: CommandOptions = {},
+): Promise<string | null> {
+	try {
+		const result = await jj(cwd, args, options);
+		return result.exitCode === 0 ? result.stdout : null;
+	} catch {
+		return null;
+	}
+}
+
 function splitLines(text: string): string[] {
 	return text
 		.split("\n")
@@ -135,6 +150,30 @@ function buildDiffArgs(options: DiffOptions): string[] {
 	return args;
 }
 
+function parseWorkingCopyLabel(raw: string): string | null {
+	let changeId: string | null = null;
+	for (const line of raw.split("\n")) {
+		const sep = line.indexOf("|");
+		const change = (sep === -1 ? line : line.slice(0, sep)).trim();
+		const bookmarks = sep === -1 ? "" : line.slice(sep + 1).trim();
+		if (changeId === null && change) changeId = change;
+		if (bookmarks) return bookmarks.replace(/\s+/g, " ");
+	}
+	return changeId;
+}
+
+function parseStatusSummary(raw: string): git.GitStatusSummary {
+	let unstaged = 0;
+	let untracked = 0;
+	for (const line of raw.split("\n")) {
+		const type = line.trim()[0];
+		if (!type) continue;
+		if (type === "A") untracked++;
+		else unstaged++;
+	}
+	return { staged: 0, unstaged, untracked };
+}
+
 // ════════════════════════════════════════════════════════════════════════════
 // Internal: Repository resolution
 // ════════════════════════════════════════════════════════════════════════════
@@ -153,7 +192,16 @@ async function hasJjWorkspaceMetadata(dir: string): Promise<boolean> {
 	// of the default workspace. Either form is a real workspace, so match on
 	// `.jj/repo` presence rather than the inner `store/` directory.
 	try {
-		await fs.stat(path.join(dir, ".jj", "repo"));
+		await fs.promises.stat(path.join(dir, ".jj", "repo"));
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+function hasJjWorkspaceMetadataSync(dir: string): boolean {
+	try {
+		fs.statSync(path.join(dir, ".jj", "repo"));
 		return true;
 	} catch {
 		return false;
@@ -180,6 +228,21 @@ async function findWorkspaceRoot(cwd: string): Promise<string | undefined> {
 	return undefined;
 }
 
+function findWorkspaceRootSync(cwd: string): string | undefined {
+	const key = path.resolve(cwd);
+	if (workspaceRootCache.has(key)) return workspaceRootCache.get(key)?.root;
+
+	for (let dir: string | undefined = key; dir; dir = parentOf(dir)) {
+		if (hasJjWorkspaceMetadataSync(dir)) {
+			workspaceRootCache.set(key, { root: dir });
+			return dir;
+		}
+	}
+
+	workspaceRootCache.set(key, {});
+	return undefined;
+}
+
 /**
  * Resolve the `.jj/repo` directory backing a workspace root, following the file
  * indirection used by non-default workspaces. `jj workspace add` writes a FILE at
@@ -190,8 +253,8 @@ async function findWorkspaceRoot(cwd: string): Promise<string | undefined> {
 async function resolveRepoDir(root: string): Promise<string> {
 	const jjDir = path.join(root, ".jj");
 	const repoPath = path.join(jjDir, "repo");
-	if ((await fs.stat(repoPath)).isFile()) {
-		const target = (await fs.readFile(repoPath, "utf8")).trim();
+	if ((await fs.promises.stat(repoPath)).isFile()) {
+		const target = (await fs.promises.readFile(repoPath, "utf8")).trim();
 		return path.resolve(jjDir, target);
 	}
 	return repoPath;
@@ -221,6 +284,56 @@ export const diff = Object.assign(
 	},
 );
 
+// ════════════════════════════════════════════════════════════════════════════
+// API: working copy
+// ════════════════════════════════════════════════════════════════════════════
+
+/** Jujutsu working-copy metadata used by status displays. */
+export const workingCopy = {
+	/**
+	 * Label `@` with its nearest bookmark, falling back to its short change ID.
+	 * Returns `null` when `jj` is unavailable or the query fails.
+	 */
+	async label(cwd: string, signal?: AbortSignal): Promise<string | null> {
+		const raw = await runOptionalText(
+			cwd,
+			[
+				"log",
+				"--no-graph",
+				"--ignore-working-copy",
+				"-r",
+				WORKING_COPY_LABEL_REVSET,
+				"-T",
+				WORKING_COPY_LABEL_TEMPLATE,
+			],
+			{ signal },
+		);
+		return raw === null ? null : parseWorkingCopyLabel(raw);
+	},
+
+	/** Parse working-copy label query output. */
+	parseLabel: parseWorkingCopyLabel,
+};
+
+// ════════════════════════════════════════════════════════════════════════════
+// API: status
+// ════════════════════════════════════════════════════════════════════════════
+
+/** Jujutsu working-copy status derived from the changes in `@`. */
+export const status = {
+	/**
+	 * Count changes in `@` relative to its parent using the Git status shape.
+	 * Jujutsu has no index, so `staged` is always zero.
+	 */
+	async summary(cwd: string, signal?: AbortSignal): Promise<git.GitStatusSummary | null> {
+		const raw = await runOptionalText(cwd, ["diff", "-r", "@", "--summary", "--ignore-working-copy"], { signal });
+		return raw === null ? null : parseStatusSummary(raw);
+	},
+
+	/** Parse `jj diff --summary` output into status counts. */
+	parse: parseStatusSummary,
+};
+
 // ════════════════════════════════════════════════════════════════════════════
 // API: repo
 // ════════════════════════════════════════════════════════════════════════════
@@ -231,6 +344,14 @@ export const repo = {
 		workspaceRootCache.clear();
 	},
 
+	/**
+	 * Resolve the current workspace root synchronously from on-disk metadata.
+	 * Intended for render paths that cannot await filesystem I/O.
+	 */
+	rootSync(cwd: string): string | null {
+		return findWorkspaceRootSync(cwd) ?? null;
+	},
+
 	/** Resolve the current Jujutsu workspace root, or `null` when `cwd` is not in a JJ repository. */
 	async root(cwd: string): Promise<string | null> {
 		return (await findWorkspaceRoot(cwd)) ?? null;

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/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();
 }
 
 /**