@hadooppei/hwcode 0.1.0

package/.pi/extensions/workflows.ts

@@ -0,0 +1,292 @@
+import { homedir, tmpdir } from "node:os";
+
+import type {
+	ExtensionAPI,
+	ExtensionCommandContext,
+	ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+
+import {
+	canonicalizeWorkspaceRoot,
+	findExternalPathReferences,
+	isPathInsideRoot,
+	resolveToolPath,
+} from "../lib/workflow-guard.ts";
+import { getWorkingDirectory } from "../lib/working-directory.ts";
+
+const STATE_TYPE = "hwcode-workflow-state";
+const AUDIT_TYPE = "hwcode-workflow-external-approval";
+const FILE_PATH_TOOLS = new Set(["read", "write", "edit", "grep", "find", "ls"]);
+
+type WorkflowMode = "vibe" | "sdd";
+
+interface ActiveWorkflowState {
+	version: 1;
+	active: true;
+	mode: WorkflowMode;
+	root: string;
+	activatedAt: string;
+}
+
+interface InactiveWorkflowState {
+	version: 1;
+	active: false;
+	deactivatedAt: string;
+}
+
+type WorkflowState = ActiveWorkflowState | InactiveWorkflowState;
+
+interface GitState {
+	initialized: boolean;
+	dirty: boolean;
+	status: string;
+}
+
+function isWorkflowState(value: unknown): value is WorkflowState {
+	if (!value || typeof value !== "object") return false;
+	const data = value as Record<string, unknown>;
+	if (data.version !== 1 || typeof data.active !== "boolean") return false;
+	if (data.active) {
+		return (data.mode === "vibe" || data.mode === "sdd")
+			&& typeof data.root === "string"
+			&& typeof data.activatedAt === "string";
+	}
+	return typeof data.deactivatedAt === "string";
+}
+
+function restoreState(ctx: ExtensionContext): WorkflowState | undefined {
+	for (const entry of [...ctx.sessionManager.getEntries()].reverse()) {
+		if (entry.type !== "custom" || entry.customType !== STATE_TYPE || !isWorkflowState(entry.data)) continue;
+		return entry.data;
+	}
+	return undefined;
+}
+
+function modeLabel(mode: WorkflowMode): string {
+	return mode === "vibe" ? "HWCode Vibe" : "HWCode SDD";
+}
+
+function notify(ctx: ExtensionContext, message: string, level: "info" | "warning" | "error" = "info"): void {
+	if (ctx.hasUI) ctx.ui.notify(message, level);
+}
+
+async function confirmWorkspace(mode: WorkflowMode, root: string, ctx: ExtensionCommandContext): Promise<boolean> {
+	if (!ctx.hasUI) return false;
+	return ctx.ui.confirm(
+		`Start ${modeLabel(mode)}?`,
+		[
+			`Project root: ${root}`,
+			"",
+			"All project work in this session will be limited to this root.",
+			"Paths inside it are allowed silently. Each external-path tool call requires separate approval.",
+		].join("\n"),
+	);
+}
+
+async function inspectOrInitializeGit(
+	pi: ExtensionAPI,
+	root: string,
+	ctx: ExtensionCommandContext,
+): Promise<GitState | undefined> {
+	const gitVersion = await pi.exec("git", ["--version"], { cwd: root });
+	if (gitVersion.code !== 0) {
+		notify(ctx, "HWCode SDD requires Git, but the git executable is unavailable.", "error");
+		return undefined;
+	}
+
+	let initialized = false;
+	let topLevel = await pi.exec("git", ["rev-parse", "--show-toplevel"], { cwd: root });
+	if (topLevel.code !== 0) {
+		if (!ctx.hasUI || !(await ctx.ui.confirm(
+			"Initialize Git repository?",
+			`HWCode SDD requires the current directory to be a Git repository root.\n\nRun git init in:\n${root}`,
+		))) return undefined;
+
+		const init = await pi.exec("git", ["init"], { cwd: root });
+		if (init.code !== 0) {
+			notify(ctx, `Git initialization failed: ${init.stderr.trim() || init.stdout.trim()}`, "error");
+			return undefined;
+		}
+		initialized = true;
+		topLevel = await pi.exec("git", ["rev-parse", "--show-toplevel"], { cwd: root });
+	}
+
+	if (topLevel.code !== 0) {
+		notify(ctx, "Unable to determine the Git repository root.", "error");
+		return undefined;
+	}
+
+	const gitRoot = canonicalizeWorkspaceRoot(topLevel.stdout.trim());
+	if (gitRoot !== root) {
+		notify(
+			ctx,
+			`HWCode SDD must start at the Git repository root. Restart it from: ${gitRoot}`,
+			"error",
+		);
+		return undefined;
+	}
+
+	const statusResult = await pi.exec(
+		"git",
+		["status", "--porcelain=v1", "--untracked-files=all"],
+		{ cwd: root },
+	);
+	if (statusResult.code !== 0) {
+		notify(ctx, `Unable to inspect Git status: ${statusResult.stderr.trim()}`, "error");
+		return undefined;
+	}
+
+	const status = statusResult.stdout.trim();
+	return { initialized, dirty: status.length > 0, status };
+}
+
+function activationPrompt(mode: WorkflowMode, root: string, git: GitState | undefined, request: string): string {
+	const context = [
+		`The ${modeLabel(mode)} workflow has been activated by its project command.`,
+		`Locked project root: ${root}`,
+	];
+	if (git) {
+		context.push(
+			`Git repository: ${git.initialized ? "initialized now" : "already present"}; working tree: ${git.dirty ? "has changes" : "clean"}.`,
+		);
+		if (git.status) context.push(`Current porcelain status:\n${git.status}`);
+	}
+	if (request) context.push(`Initial user request:\n${request}`);
+	return `/skill:hwcode-${mode} ${context.join("\n\n")}`;
+}
+
+function workflowSystemPrompt(state: ActiveWorkflowState): string {
+	const common = [
+		`HWCODE WORKFLOW ACTIVE: ${state.mode.toUpperCase()}`,
+		`The sole project root for this session is ${state.root}.`,
+		"Keep all reads, writes, commands, generated files, and project work inside that root by default.",
+		"An external-path approval applies only to the exact tool call that requested it. Never evade the guard through indirection, symlinks, subprocesses, alternate tools, or encoded commands.",
+		"If external storage such as /tmp is genuinely useful, explain why and let the tool-call approval request obtain user consent.",
+	];
+	if (state.mode === "sdd") {
+		common.push(
+			"Follow the SDD phase gates. Do not implement production behavior before requirements, design, test plan, and tasks are complete and explicitly approved.",
+			"Develop tests before implementation with a red-green-refactor loop. Return to specification when expected behavior or a test scenario is uncertain.",
+			"Never create a Git commit unless the user explicitly approves that commit.",
+		);
+	}
+	return common.join("\n");
+}
+
+export default function (pi: ExtensionAPI) {
+	let activeState: ActiveWorkflowState | undefined;
+
+	async function activate(mode: WorkflowMode, args: string, ctx: ExtensionCommandContext): Promise<void> {
+		if (!ctx.isIdle()) {
+			notify(ctx, `Wait for the current response to finish before starting ${modeLabel(mode)}.`, "warning");
+			return;
+		}
+
+		const root = canonicalizeWorkspaceRoot(getWorkingDirectory(ctx.sessionManager));
+		if (!(await confirmWorkspace(mode, root, ctx))) {
+			notify(ctx, `${modeLabel(mode)} was not started.`, "warning");
+			return;
+		}
+
+		const git = mode === "sdd" ? await inspectOrInitializeGit(pi, root, ctx) : undefined;
+		if (mode === "sdd" && !git) return;
+
+		activeState = {
+			version: 1,
+			active: true,
+			mode,
+			root,
+			activatedAt: new Date().toISOString(),
+		};
+		pi.appendEntry<WorkflowState>(STATE_TYPE, activeState);
+		notify(ctx, `${modeLabel(mode)} activated. Project root locked to ${root}.`);
+		pi.sendUserMessage(activationPrompt(mode, root, git, args.trim()), { expandPromptTemplates: true });
+	}
+
+	pi.registerCommand("hwcode-vibe", {
+		description: "Start the directory-locked HWCode Vibe workflow",
+		handler: async (args, ctx) => activate("vibe", args, ctx),
+	});
+
+	pi.registerCommand("hwcode-sdd", {
+		description: "Start the Git-root-locked HWCode spec-driven workflow",
+		handler: async (args, ctx) => activate("sdd", args, ctx),
+	});
+
+	pi.on("session_start", async (_event, ctx) => {
+		const restored = restoreState(ctx);
+		if (!restored?.active) {
+			activeState = undefined;
+			return;
+		}
+
+		const currentRoot = canonicalizeWorkspaceRoot(getWorkingDirectory(ctx.sessionManager));
+		if (currentRoot !== restored.root) {
+			activeState = undefined;
+			pi.appendEntry<WorkflowState>(STATE_TYPE, {
+				version: 1,
+				active: false,
+				deactivatedAt: new Date().toISOString(),
+			});
+			notify(ctx, "Stored HWCode workflow disabled because the current directory changed.", "warning");
+			return;
+		}
+
+		activeState = restored;
+		notify(ctx, `${modeLabel(restored.mode)} restored. Root: ${restored.root}`);
+	});
+
+	pi.on("before_agent_start", async (event) => {
+		if (!activeState) return undefined;
+		return { systemPrompt: `${event.systemPrompt}\n\n${workflowSystemPrompt(activeState)}` };
+	});
+
+	pi.on("tool_call", async (event, ctx) => {
+		if (!activeState) return undefined;
+
+		const input = event.input as Record<string, unknown>;
+		let external: Array<{ raw: string; resolved: string }> = [];
+		if (FILE_PATH_TOOLS.has(event.toolName) && typeof input.path === "string") {
+			const resolved = resolveToolPath(activeState.root, input.path, homedir());
+			if (!isPathInsideRoot(activeState.root, resolved)) external = [{ raw: input.path, resolved }];
+		} else if (event.toolName === "bash" && typeof input.command === "string") {
+			external = findExternalPathReferences(input.command, activeState.root, {
+				home: homedir(),
+				tmpdir: tmpdir(),
+			});
+		}
+
+		if (external.length === 0) return undefined;
+		const details = external.map((entry) => `• ${entry.raw} → ${entry.resolved}`).join("\n");
+		if (!ctx.hasUI) {
+			return {
+				block: true,
+				reason: `External path requires interactive one-call approval:\n${details}`,
+			};
+		}
+
+		const allowed = await ctx.ui.confirm(
+			"Allow external path for this call?",
+			[
+				`${modeLabel(activeState.mode)} is locked to ${activeState.root}.`,
+				"This tool call references paths outside that root:",
+				"",
+				details,
+				"",
+				"Approval applies only to this tool call.",
+			].join("\n"),
+		);
+		if (!allowed) {
+			return { block: true, reason: `User denied external path access:\n${details}` };
+		}
+
+		pi.appendEntry(AUDIT_TYPE, {
+			mode: activeState.mode,
+			root: activeState.root,
+			toolName: event.toolName,
+			external,
+			approvedAt: new Date().toISOString(),
+		});
+		return undefined;
+	});
+}

package/.pi/lib/command-filter.ts

@@ -0,0 +1,49 @@
+export const DEFAULT_HIDDEN_COMMANDS = [
+	"export",
+	"import",
+	"share",
+	"name",
+	"changelog",
+	"fork",
+	"clone",
+	"trust",
+	"reload",
+	"review",
+	"welcome",
+	"llama",
+	"skill:hwcode-vibe",
+	"skill:hwcode-sdd",
+] as const;
+
+interface ProjectSettings {
+	hwcode?: {
+		hiddenCommands?: unknown;
+	};
+}
+
+export interface CommandSuggestion {
+	value: string;
+}
+
+export function normalizeCommandName(command: string): string {
+	return command.trim().replace(/^\/+/, "").toLowerCase();
+}
+
+export function parseHiddenCommands(settingsText: string): Set<string> {
+	const settings = JSON.parse(settingsText) as ProjectSettings;
+	const configured = settings.hwcode?.hiddenCommands;
+	if (configured === undefined) return new Set(DEFAULT_HIDDEN_COMMANDS);
+	if (!Array.isArray(configured) || configured.some((entry) => typeof entry !== "string")) {
+		throw new Error("hwcode.hiddenCommands must be an array of command-name strings");
+	}
+	return new Set(configured.map(normalizeCommandName).filter(Boolean));
+}
+
+export function filterCommandSuggestions<T extends CommandSuggestion>(
+	items: T[],
+	prefix: string,
+	hiddenCommands: ReadonlySet<string>,
+): T[] {
+	if (!prefix.startsWith("/")) return items;
+	return items.filter((item) => !hiddenCommands.has(normalizeCommandName(item.value)));
+}

package/.pi/lib/pixel-font.ts

@@ -0,0 +1,264 @@
+import type { Theme, ThemeColor } from "@earendil-works/pi-coding-agent";
+
+type Point = readonly [x: number, y: number];
+type Stroke = readonly Point[];
+
+interface VectorGlyph {
+  strokes: readonly Stroke[];
+}
+
+const point = (x: number, y: number): Point => [x, y];
+
+function path(...coordinates: number[]): Point[] {
+  const points: Point[] = [];
+  for (let index = 0; index < coordinates.length; index += 2) {
+    points.push(point(coordinates[index], coordinates[index + 1]));
+  }
+  return points;
+}
+
+function cubic(start: Point, control1: Point, control2: Point, end: Point, steps = 18): Point[] {
+  const points: Point[] = [];
+  for (let step = 0; step <= steps; step++) {
+    const t = step / steps;
+    const inverse = 1 - t;
+    points.push(point(
+      inverse ** 3 * start[0]
+        + 3 * inverse ** 2 * t * control1[0]
+        + 3 * inverse * t ** 2 * control2[0]
+        + t ** 3 * end[0],
+      inverse ** 3 * start[1]
+        + 3 * inverse ** 2 * t * control1[1]
+        + 3 * inverse * t ** 2 * control2[1]
+        + t ** 3 * end[1],
+    ));
+  }
+  return points;
+}
+
+function arc(
+  centerX: number,
+  centerY: number,
+  radiusX: number,
+  radiusY: number,
+  startDegrees: number,
+  endDegrees: number,
+  steps = 28,
+): Point[] {
+  const points: Point[] = [];
+  for (let step = 0; step <= steps; step++) {
+    const degrees = startDegrees + (endDegrees - startDegrees) * (step / steps);
+    const radians = degrees * Math.PI / 180;
+    points.push(point(
+      centerX + Math.cos(radians) * radiusX,
+      centerY + Math.sin(radians) * radiusY,
+    ));
+  }
+  return points;
+}
+
+function joinPaths(...parts: readonly Point[][]): Point[] {
+  return parts.flatMap((part, index) => index === 0 ? part : part.slice(1));
+}
+
+// Normalized monoline glyphs. They are rasterized at the density selected for the
+// current terminal instead of being enlarged from a fixed low-resolution bitmap.
+const VECTOR_FONT: Record<string, VectorGlyph> = {
+  A: { strokes: [path(1, 11, 4, 1, 7, 11), path(2.2, 7, 5.8, 7)] },
+  B: { strokes: [
+    path(1, 1, 1, 11),
+    joinPaths(path(1, 1, 4.4, 1), cubic(point(4.4, 1), point(7.4, 1), point(7.4, 6), point(4.4, 6)), path(4.4, 6, 1, 6)),
+    joinPaths(path(1, 6, 4.7, 6), cubic(point(4.7, 6), point(7.6, 6), point(7.6, 11), point(4.7, 11)), path(4.7, 11, 1, 11)),
+  ] },
+  C: { strokes: [arc(4, 6, 3.2, 5, -45, -315)] },
+  D: { strokes: [
+    path(1, 1, 1, 11),
+    joinPaths(
+      cubic(point(1, 1), point(5.2, 1), point(7, 2.6), point(7, 6)),
+      cubic(point(7, 6), point(7, 9.4), point(5.2, 11), point(1, 11)),
+    ),
+  ] },
+  E: { strokes: [path(7, 1, 1, 1, 1, 11, 7, 11), path(1, 6, 6, 6)] },
+  F: { strokes: [path(7, 1, 1, 1, 1, 11), path(1, 6, 6, 6)] },
+  G: { strokes: [arc(4, 6, 3.2, 5, -45, -315), path(7.1, 6, 4.4, 6), path(7.1, 6, 7.1, 9)] },
+  H: { strokes: [path(1, 1, 1, 11), path(7, 1, 7, 11), path(1, 6, 7, 6)] },
+  I: { strokes: [path(1, 1, 7, 1), path(4, 1, 4, 11), path(1, 11, 7, 11)] },
+  J: { strokes: [
+    path(1, 1, 7, 1),
+    joinPaths(path(7, 1, 7, 8), arc(4, 8, 3, 3, 0, 150, 18)),
+  ] },
+  K: { strokes: [path(1, 1, 1, 11), path(7, 1, 1, 6, 7, 11)] },
+  L: { strokes: [path(1, 1, 1, 11, 7, 11)] },
+  M: { strokes: [path(1, 11, 1, 1, 4, 6, 7, 1, 7, 11)] },
+  N: { strokes: [path(1, 11, 1, 1, 7, 11, 7, 1)] },
+  O: { strokes: [arc(4, 6, 3.2, 5, 0, 360, 36)] },
+  P: { strokes: [
+    path(1, 11, 1, 1),
+    joinPaths(path(1, 1, 4.4, 1), cubic(point(4.4, 1), point(7.5, 1), point(7.5, 6), point(4.4, 6)), path(4.4, 6, 1, 6)),
+  ] },
+  Q: { strokes: [arc(4, 6, 3.2, 5, 0, 360, 36), path(4.8, 8.2, 7.4, 11.3)] },
+  R: { strokes: [
+    path(1, 11, 1, 1),
+    joinPaths(path(1, 1, 4.4, 1), cubic(point(4.4, 1), point(7.5, 1), point(7.5, 6), point(4.4, 6)), path(4.4, 6, 1, 6)),
+    path(4.3, 6, 7.2, 11),
+  ] },
+  S: { strokes: [joinPaths(
+    cubic(point(7.1, 2), point(5.6, 0.4), point(1, 0.5), point(1, 3.5)),
+    cubic(point(1, 3.5), point(1, 5.7), point(7, 5.4), point(7, 8.5)),
+    cubic(point(7, 8.5), point(7, 11.5), point(2.3, 11.8), point(0.8, 10)),
+  )] },
+  T: { strokes: [path(0.7, 1, 7.3, 1), path(4, 1, 4, 11)] },
+  U: { strokes: [path(1, 1, 1, 8), arc(4, 8, 3, 3, 180, 0, 22), path(7, 8, 7, 1)] },
+  V: { strokes: [path(0.8, 1, 4, 11, 7.2, 1)] },
+  W: { strokes: [path(0.5, 1, 2, 11, 4, 6, 6, 11, 7.5, 1)] },
+  X: { strokes: [path(0.8, 1, 7.2, 11), path(7.2, 1, 0.8, 11)] },
+  Y: { strokes: [path(0.8, 1, 4, 6, 7.2, 1), path(4, 6, 4, 11)] },
+  Z: { strokes: [path(0.8, 1, 7.2, 1, 0.8, 11, 7.2, 11)] },
+};
+
+export const THEME_COLORS: readonly ThemeColor[] = [
+  "accent", "border", "borderAccent", "borderMuted", "success", "error", "warning",
+  "muted", "dim", "text", "thinkingText", "searchMatchText", "userMessageText",
+  "customMessageText", "customMessageLabel", "toolTitle", "toolOutput", "mdHeading",
+  "mdLink", "mdLinkUrl", "mdCode", "mdCodeBlock", "mdCodeBlockBorder", "mdQuote",
+  "mdQuoteBorder", "mdHr", "mdListBullet", "toolDiffAdded", "toolDiffRemoved",
+  "toolDiffContext", "syntaxComment", "syntaxKeyword", "syntaxFunction", "syntaxVariable",
+  "syntaxString", "syntaxNumber", "syntaxType", "syntaxOperator", "syntaxPunctuation",
+  "thinkingOff", "thinkingMinimal", "thinkingLow", "thinkingMedium", "thinkingHigh",
+  "thinkingXhigh", "thinkingMax", "bashMode",
+];
+
+const THEME_COLOR_SET = new Set<string>(THEME_COLORS);
+const GLYPH_WIDTH = 8;
+const GLYPH_HEIGHT = 12;
+const GLYPH_GAP = 1;
+const BRAILLE_COLUMNS = 2;
+const BRAILLE_ROWS = 4;
+const GLYPH_CACHE = new Map<string, string[]>();
+const BRAILLE_DOTS = [
+  [0, 0, 0x01], [0, 1, 0x02], [0, 2, 0x04],
+  [1, 0, 0x08], [1, 1, 0x10], [1, 2, 0x20],
+  [0, 3, 0x40], [1, 3, 0x80],
+] as const;
+
+export function isThemeColor(value: unknown): value is ThemeColor {
+  return typeof value === "string" && THEME_COLOR_SET.has(value);
+}
+
+export interface PixelTextResult {
+  lines: string[];
+  height: number;
+  scale: number;
+}
+
+function segmentDistanceSquared(x: number, y: number, start: Point, end: Point, scale: number): number {
+  const startX = start[0] * scale;
+  const startY = start[1] * scale;
+  const deltaX = (end[0] - start[0]) * scale;
+  const deltaY = (end[1] - start[1]) * scale;
+  const lengthSquared = deltaX * deltaX + deltaY * deltaY;
+  const projection = lengthSquared === 0
+    ? 0
+    : Math.max(0, Math.min(1, ((x - startX) * deltaX + (y - startY) * deltaY) / lengthSquared));
+  const nearestX = startX + projection * deltaX;
+  const nearestY = startY + projection * deltaY;
+  return (x - nearestX) ** 2 + (y - nearestY) ** 2;
+}
+
+function rasterizeGlyph(letter: string, scale: number): boolean[][] {
+  const width = GLYPH_WIDTH * scale;
+  const height = GLYPH_HEIGHT * scale;
+  const bitmap = Array.from({ length: height }, () => Array<boolean>(width).fill(false));
+  const glyph = VECTOR_FONT[letter] ?? VECTOR_FONT.X;
+  const radius = Math.max(0.72, scale * 0.48);
+  const radiusSquared = radius * radius;
+
+  for (const stroke of glyph.strokes) {
+    for (let index = 0; index < stroke.length - 1; index++) {
+      const start = stroke[index];
+      const end = stroke[index + 1];
+      const minX = Math.max(0, Math.floor(Math.min(start[0], end[0]) * scale - radius));
+      const maxX = Math.min(width - 1, Math.ceil(Math.max(start[0], end[0]) * scale + radius));
+      const minY = Math.max(0, Math.floor(Math.min(start[1], end[1]) * scale - radius));
+      const maxY = Math.min(height - 1, Math.ceil(Math.max(start[1], end[1]) * scale + radius));
+
+      for (let y = minY; y <= maxY; y++) {
+        for (let x = minX; x <= maxX; x++) {
+          if (segmentDistanceSquared(x + 0.5, y + 0.5, start, end, scale) <= radiusSquared) {
+            bitmap[y][x] = true;
+          }
+        }
+      }
+    }
+  }
+
+  return bitmap;
+}
+
+function encodeBraille(bitmap: readonly boolean[][]): string[] {
+  const height = bitmap.length;
+  const width = bitmap[0]?.length ?? 0;
+  const lines: string[] = [];
+
+  for (let originY = 0; originY < height; originY += BRAILLE_ROWS) {
+    let line = "";
+    for (let originX = 0; originX < width; originX += BRAILLE_COLUMNS) {
+      let mask = 0;
+      for (const [offsetX, offsetY, dot] of BRAILLE_DOTS) {
+        if (bitmap[originY + offsetY]?.[originX + offsetX]) mask |= dot;
+      }
+      line += mask === 0 ? " " : String.fromCodePoint(0x2800 + mask);
+    }
+    lines.push(line);
+  }
+
+  return lines;
+}
+
+function renderGlyph(letter: string, scale: number): string[] {
+  const cacheKey = `${letter}:${scale}`;
+  const cached = GLYPH_CACHE.get(cacheKey);
+  if (cached) return cached;
+  const rendered = encodeBraille(rasterizeGlyph(letter, scale));
+  GLYPH_CACHE.set(cacheKey, rendered);
+  return rendered;
+}
+
+export function renderPixelText(
+  text: string,
+  colors: readonly ThemeColor[],
+  theme: Theme,
+  availableWidth: number,
+  availableHeight: number,
+): PixelTextResult {
+  const letters = [...text.toUpperCase()];
+  const widthPerScale = letters.length * (GLYPH_WIDTH / BRAILLE_COLUMNS)
+    + Math.max(0, letters.length - 1) * GLYPH_GAP;
+  const heightPerScale = GLYPH_HEIGHT / BRAILLE_ROWS;
+  const widthScale = Math.floor((availableWidth - 4) / widthPerScale);
+  const heightScale = Math.floor(availableHeight / heightPerScale);
+  const scale = Math.min(widthScale, heightScale);
+
+  if (scale < 1) {
+    const leftPadding = " ".repeat(Math.max(0, Math.floor((availableWidth - letters.length) / 2)));
+    const line = letters
+      .map((letter, index) => theme.fg(colors[index % colors.length] ?? "accent", letter))
+      .join("");
+    return { lines: [`${leftPadding}${line}`], height: 1, scale: 0 };
+  }
+
+  const glyphs = letters.map((letter) => renderGlyph(letter, scale));
+  const gap = " ".repeat(GLYPH_GAP * scale);
+  const renderedWidth = widthPerScale * scale;
+  const leftPadding = " ".repeat(Math.max(0, Math.floor((availableWidth - renderedWidth) / 2)));
+  const height = heightPerScale * scale;
+  const lines: string[] = [];
+
+  for (let row = 0; row < height; row++) {
+    const segments = glyphs.map((glyph, index) =>
+      theme.fg(colors[index % colors.length] ?? "accent", glyph[row]));
+    lines.push(`${leftPadding}${segments.join(gap)}`);
+  }
+
+  return { lines, height, scale };
+}

package/.pi/lib/welcome-input.ts

@@ -0,0 +1,18 @@
+function isPlainKittyEnter(data: string): boolean {
+	const match = data.match(/^\x1b\[(\d+)(?::(\d*))?(?::(\d+))?(?:;(\d+))?(?::(\d+))?u$/);
+	if (!match) return false;
+	const codepoint = Number(match[1]);
+	const modifier = match[4] === undefined ? 1 : Number(match[4]);
+	const eventType = match[5] === undefined ? 1 : Number(match[5]);
+	return (codepoint === 13 || codepoint === 57414) && modifier === 1 && eventType !== 3;
+}
+
+export function isSubmitKey(data: string): boolean {
+	if (data === "\r" || data === "\x1bOM") return true;
+	if (/^\x1b\[27;1;13~$/.test(data)) return true;
+	return isPlainKittyEnter(data);
+}
+
+export function shouldDismissWelcomeOnSubmit(data: string, editorText: string): boolean {
+	return editorText.trim().length > 0 && isSubmitKey(data);
+}