@oh-my-pi/pi-coding-agent 15.7.3 → 15.7.5

package/src/tui/output-block.ts

@@ -20,10 +20,10 @@ export interface OutputBlockOptions {
 }
 
 const BORDER_SHIMMER_TICK_MS = 50;
-/** Duration of one full clockwise lap around the border, in ms. Fixed so a box
- * growing (new output line) or resizing only nudges the segment proportionally
- * instead of teleporting it. */
-const BORDER_LAP_MS = 4000;
+/** Duration of one full left↔right↔left bounce of the bottom-edge segment, in
+ * ms. Position is derived from the wall clock against this fixed cycle so a
+ * resize only nudges the segment proportionally instead of teleporting it. */
+const BORDER_BOUNCE_MS = 3000;
 /** Length, in border cells, of the moving segment. */
 const BORDER_SEGMENT_LEN = 8;
 
@@ -36,38 +36,25 @@ export function borderShimmerTick(): number {
 	return Math.floor(Date.now() / BORDER_SHIMMER_TICK_MS);
 }
 
-/** Ease-in-out so the segment decelerates into and accelerates out of corners. */
+/** Ease-in-out so the segment decelerates into and accelerates out of each wall. */
 function easeInOutQuad(t: number): number {
 	return t < 0.5 ? 2 * t * t : 1 - (-2 * t + 2) ** 2 / 2;
 }
 
 /**
- * Perimeter index of the moving segment's head for a box of inner width `W` and
- * height `H` at time `now`. The lap is split across the four edges in proportion
- * to their length (so the average speed is uniform) and each edge is eased, for a
- * deliberate, non-linear glide that slows at every corner. Position is derived
- * from the wall clock against a fixed lap duration, so a perimeter change (new
- * row / resize) shifts the head by at most a cell or two — no reset.
+ * Column of the travelling segment's center on the bottom edge for a box of
+ * inner width `W` at time `now`. The segment bounces left → right → left across
+ * the bottom border: a triangle wave over one full there-and-back cycle, eased
+ * per leg so it slows as it nears each wall before reversing. Position is
+ * derived from the wall clock against a fixed cycle, so a resize shifts the
+ * center proportionally — no reset.
  */
-export function borderSegmentHead(W: number, H: number, now: number): number {
-	const P = 2 * W + 2 * H - 4;
-	if (P <= 0) return 0;
-	// Edge cell counts, clockwise from top-left: top, right, bottom, left.
-	const edgeLens = [W, H - 1, W - 1, H - 2];
-	const t = (((now % BORDER_LAP_MS) + BORDER_LAP_MS) % BORDER_LAP_MS) / BORDER_LAP_MS;
-	let acc = 0;
-	let start = 0;
-	for (let i = 0; i < 4; i++) {
-		const len = edgeLens[i]!;
-		const frac = len / P;
-		if (len > 0 && t < acc + frac) {
-			const lf = (t - acc) / frac;
-			return (start + Math.floor(easeInOutQuad(lf) * len)) % P;
-		}
-		acc += frac;
-		start += len;
-	}
-	return P - 1;
+export function borderSegmentHeadCol(W: number, now: number): number {
+	if (W <= 1) return 0;
+	const phase = (((now % BORDER_BOUNCE_MS) + BORDER_BOUNCE_MS) % BORDER_BOUNCE_MS) / BORDER_BOUNCE_MS;
+	// Triangle: 0→1 rightward over the first half, 1→0 leftward over the second.
+	const leg = phase < 0.5 ? phase * 2 : 2 - phase * 2;
+	return easeInOutQuad(leg) * (W - 1);
 }
 
 /**
@@ -164,30 +151,26 @@ export function renderOutputBlock(options: OutputBlockOptions, theme: Theme): st
 	const W = lineWidth;
 	const animate = (options.animate ?? false) && (state === "running" || state === "pending") && W >= 2 && H >= 2;
 
-	// ── Segment geometry: one dark run travels the outer edge clockwise,
-	// top → right → bottom → left → top. ──
-	const P = animate ? 2 * W + 2 * H - 4 : 0;
-	const segLen = Math.min(BORDER_SEGMENT_LEN, P);
-	const head = animate ? borderSegmentHead(W, H, Date.now()) : 0;
+	// ── Segment geometry: one dark run bounces left ↔ right along the bottom
+	// edge only. The top, interior separators, and side borders stay the flat
+	// accent color. ──
+	const segLen = animate ? Math.min(BORDER_SEGMENT_LEN, W) : 0;
+	const head = animate ? borderSegmentHeadCol(W, Date.now()) : 0;
+	const segHalf = segLen / 2;
 	const segAnsi = animate ? (darkenFgAnsi(theme.getFgAnsi(borderColor), 0.4) ?? theme.getFgAnsi("borderMuted")) : "";
 	const seg = (text: string) => `${segAnsi}${text}\x1b[39m`;
 
-	// Perimeter index of border cell (row r, col c), clockwise from top-left.
-	const perimIndex = (r: number, c: number): number => {
-		if (r === 0) return c;
-		if (c === W - 1) return W - 1 + r;
-		if (r === H - 1) return W - 1 + (H - 1) + (W - 1 - c);
-		return W - 1 + (H - 1) + (W - 1) + (H - 1 - r);
-	};
-	const isLit = (idx: number): boolean => (((idx - head) % P) + P) % P < segLen;
-	// Color a run of border glyphs starting at (row r, col startCol), grouping
+	// A bottom-edge column is lit when it lies within half a segment of the
+	// travelling center.
+	const isLit = (col: number): boolean => Math.abs(col - head) < segHalf;
+	// Color a run of bottom-edge glyphs starting at column `startCol`, grouping
 	// consecutive same-state cells so each run emits a single escape pair.
-	const colorEdge = (glyphs: string, r: number, startCol: number): string => {
+	const colorEdge = (glyphs: string, startCol: number): string => {
 		let out = "";
 		let runLit: boolean | null = null;
 		let buf = "";
 		for (let i = 0; i < glyphs.length; i++) {
-			const lit = isLit(perimIndex(r, startCol + i));
+			const lit = isLit(startCol + i);
 			if (lit !== runLit) {
 				if (runLit !== null) out += (runLit ? seg : border)(buf);
 				buf = "";
@@ -199,10 +182,7 @@ export function renderOutputBlock(options: OutputBlockOptions, theme: Theme): st
 		return out;
 	};
 
-	const renderBar = (
-		row: { leftChar: string; rightChar: string; label?: string; meta?: string },
-		r: number,
-	): string => {
+	const renderBar = (row: { leftChar: string; rightChar: string; label?: string; meta?: string }): string => {
 		const leftGlyphs = `${row.leftChar}${cap}`;
 		const rightGlyph = row.rightChar;
 		if (lineWidth <= 0) return border(leftGlyphs) + border(rightGlyph);
@@ -215,36 +195,22 @@ export function renderOutputBlock(options: OutputBlockOptions, theme: Theme): st
 		const labelWidth = visibleWidth(trimmedLabel);
 		const fillCount = Math.max(0, lineWidth - leftWidth - labelWidth - rightWidth);
 		const fillGlyphs = h.repeat(fillCount);
-		if (!animate) {
-			return `${border(leftGlyphs)}${trimmedLabel}${border(fillGlyphs)}${border(rightGlyph)}`;
-		}
-		if (r === 0 || r === H - 1) {
-			// Top/bottom edge: the whole horizontal run lies on the perimeter.
-			const leftStr = colorEdge(leftGlyphs, r, 0);
-			const fillStr = colorEdge(fillGlyphs, r, leftWidth + labelWidth);
-			const rightStr = colorEdge(rightGlyph, r, lineWidth - rightWidth);
-			return `${leftStr}${trimmedLabel}${fillStr}${rightStr}`;
-		}
-		// Interior separator: only the first/last cell sit on the outer edge.
-		return `${colorEdge(row.leftChar, r, 0)}${border(cap)}${trimmedLabel}${border(fillGlyphs)}${colorEdge(rightGlyph, r, lineWidth - rightWidth)}`;
+		return `${border(leftGlyphs)}${trimmedLabel}${border(fillGlyphs)}${border(rightGlyph)}`;
 	};
 
-	const renderBottom = (row: { leftChar: string; rightChar: string }, r: number): string => {
+	const renderBottom = (row: { leftChar: string; rightChar: string }): string => {
 		const leftGlyphs = `${row.leftChar}${cap}`;
 		const rightGlyph = row.rightChar;
 		const fillCount = Math.max(0, lineWidth - visibleWidth(leftGlyphs) - visibleWidth(rightGlyph));
 		const fillGlyphs = h.repeat(fillCount);
 		if (!animate) return `${border(leftGlyphs)}${border(fillGlyphs)}${border(rightGlyph)}`;
-		const leftStr = colorEdge(leftGlyphs, r, 0);
-		const fillStr = colorEdge(fillGlyphs, r, visibleWidth(leftGlyphs));
-		const rightStr = colorEdge(rightGlyph, r, lineWidth - visibleWidth(rightGlyph));
+		const leftStr = colorEdge(leftGlyphs, 0);
+		const fillStr = colorEdge(fillGlyphs, visibleWidth(leftGlyphs));
+		const rightStr = colorEdge(rightGlyph, lineWidth - visibleWidth(rightGlyph));
 		return `${leftStr}${fillStr}${rightStr}`;
 	};
 
-	const renderContent = (inner: string, r: number): string => {
-		if (!animate) return `${border(`${v} `)}${inner}${border(v)}`;
-		return `${colorEdge(v, r, 0)} ${inner}${colorEdge(v, r, lineWidth - 1)}`;
-	};
+	const renderContent = (inner: string): string => `${border(`${v} `)}${inner}${border(v)}`;
 
 	const lines: string[] = [];
 	for (let r = 0; r < H; r++) {
@@ -254,11 +220,7 @@ export function renderOutputBlock(options: OutputBlockOptions, theme: Theme): st
 			continue;
 		}
 		const line =
-			row.kind === "bar"
-				? renderBar(row, r)
-				: row.kind === "bottom"
-					? renderBottom(row, r)
-					: renderContent(row.inner, r);
+			row.kind === "bar" ? renderBar(row) : row.kind === "bottom" ? renderBottom(row) : renderContent(row.inner);
 		lines.push(padToWidth(line, lineWidth, bgFn));
 	}
 

package/src/utils/git.ts

@@ -1261,9 +1261,15 @@ export async function clone(url: string, targetDir: string, options: CloneOption
 	const absoluteTarget = path.resolve(targetDir);
 	await fs.promises.mkdir(path.dirname(absoluteTarget), { recursive: true });
 
-	const args = ["clone", "--depth", "1"];
+	// `git clone --depth 1 --single-branch` only fetches the tip of the target
+	// branch, so any subsequent `git checkout <sha>` for a non-tip commit fails
+	// with "reference is not a tree". When the caller pinned a specific SHA we
+	// fall back to a full clone so the object is guaranteed to be present.
+	const shallow = !options.sha;
+	const args = ["clone"];
+	if (shallow) args.push("--depth", "1");
 	if (options.ref) args.push("--branch", options.ref, "--single-branch");
-	else args.push("--single-branch");
+	else if (shallow) args.push("--single-branch");
 	args.push(url, absoluteTarget);
 
 	try {
@@ -1273,7 +1279,7 @@ export async function clone(url: string, targetDir: string, options: CloneOption
 				await checkout(absoluteTarget, options.sha, options.signal);
 			} catch {
 				await fs.promises.rm(absoluteTarget, { force: true, recursive: true });
-				throw new Error(`Failed to checkout SHA ${options.sha} - shallow clone may not contain this commit`);
+				throw new Error(`Failed to checkout SHA ${options.sha} in cloned repository ${url}`);
 			}
 		}
 	} catch (err) {