@sheepbun/yips 0.1.1

package/dist/session-store.js

@@ -0,0 +1,211 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.slugifySessionNameFromMessage = slugifySessionNameFromMessage;
+exports.getFirstUserMessage = getFirstUserMessage;
+exports.createSessionFileFromHistory = createSessionFileFromHistory;
+exports.writeSessionFile = writeSessionFile;
+exports.listSessions = listSessions;
+exports.loadSession = loadSession;
+const promises_1 = require("node:fs/promises");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const SESSION_DIR = (0, node_path_1.join)((0, node_os_1.homedir)(), ".yips", "memory");
+function pad2(value) {
+    return value.toString().padStart(2, "0");
+}
+function toSessionTimestamp(now) {
+    return [
+        now.getFullYear(),
+        "-",
+        pad2(now.getMonth() + 1),
+        "-",
+        pad2(now.getDate()),
+        "_",
+        pad2(now.getHours()),
+        "-",
+        pad2(now.getMinutes()),
+        "-",
+        pad2(now.getSeconds())
+    ].join("");
+}
+function toDisplayTitle(sessionName) {
+    const words = sessionName
+        .replace(/_/g, " ")
+        .trim()
+        .split(/\s+/u)
+        .filter((word) => word.length > 0);
+    if (words.length === 0) {
+        return "Session";
+    }
+    return words
+        .map((word) => `${word[0]?.toUpperCase() ?? ""}${word.slice(1).toLowerCase()}`)
+        .join(" ");
+}
+function parseFileStem(path) {
+    const stem = (0, node_path_1.basename)(path, ".md");
+    const parts = stem.split("_", 3);
+    if (parts.length >= 3) {
+        const datePart = parts[0] ?? "";
+        const timePart = parts[1] ?? "";
+        const sessionName = stem.slice(`${datePart}_${timePart}_`.length);
+        if (datePart.includes("-")) {
+            const dt = new Date(`${datePart}T${timePart.replace(/-/g, ":")}`);
+            if (!Number.isNaN(dt.valueOf())) {
+                return { timestamp: dt, sessionName };
+            }
+        }
+        else if (datePart.length === 8 && timePart.length >= 6) {
+            const year = Number.parseInt(datePart.slice(0, 4), 10);
+            const month = Number.parseInt(datePart.slice(4, 6), 10);
+            const day = Number.parseInt(datePart.slice(6, 8), 10);
+            const hour = Number.parseInt(timePart.slice(0, 2), 10);
+            const minute = Number.parseInt(timePart.slice(2, 4), 10);
+            const second = Number.parseInt(timePart.slice(4, 6), 10);
+            const dt = new Date(year, month - 1, day, hour, minute, second);
+            if (!Number.isNaN(dt.valueOf())) {
+                return { timestamp: dt, sessionName };
+            }
+        }
+    }
+    return {
+        timestamp: new Date(0),
+        sessionName: stem
+    };
+}
+function formatDisplayTimestamp(timestamp) {
+    const year = timestamp.getFullYear();
+    const month = timestamp.getMonth() + 1;
+    const day = timestamp.getDate();
+    const hours = timestamp.getHours();
+    const minutes = pad2(timestamp.getMinutes());
+    const amPm = hours < 12 ? "AM" : "PM";
+    const displayHour = hours === 0 ? 12 : hours > 12 ? hours - 12 : hours;
+    return `${year}-${month}-${day} @ ${displayHour.toString().padStart(2, " ")}:${minutes} ${amPm}`;
+}
+function toDisplay(sessionName, timestamp) {
+    return `${formatDisplayTimestamp(timestamp)}: ${toDisplayTitle(sessionName)}`;
+}
+function parseConversation(content) {
+    const marker = "## Conversation";
+    const markerIndex = content.indexOf(marker);
+    const section = markerIndex >= 0
+        ? content.slice(markerIndex + marker.length).split("\n---")[0] ?? ""
+        : content;
+    const history = [];
+    const lines = section.split(/\r?\n/u);
+    for (const rawLine of lines) {
+        const line = rawLine.trimEnd();
+        const roleMatch = line.match(/^\*\*([^*]+)\*\*:\s*(.*)$/u);
+        if (roleMatch) {
+            const roleName = (roleMatch[1] ?? "").trim();
+            const text = roleMatch[2] ?? "";
+            if (roleName.toLowerCase() === "yips") {
+                history.push({ role: "assistant", content: text });
+            }
+            else {
+                history.push({ role: "user", content: text });
+            }
+            continue;
+        }
+        const systemMatch = line.match(/^\*\[System:\s*(.*)\]\*$/u);
+        if (systemMatch) {
+            history.push({ role: "system", content: systemMatch[1] ?? "" });
+            continue;
+        }
+        if (line.trim().length === 0) {
+            continue;
+        }
+        const last = history[history.length - 1];
+        if (last) {
+            last.content = `${last.content}\n${line}`.trimEnd();
+        }
+    }
+    return history;
+}
+function slugifySessionNameFromMessage(message) {
+    const base = message.toLowerCase().trim().replace(/[^a-z0-9\s]/g, "");
+    if (base.length === 0) {
+        return "session";
+    }
+    const slug = base.replace(/\s+/g, "_").slice(0, 50).replace(/_+$/g, "");
+    return slug.length > 0 ? slug : "session";
+}
+function getFirstUserMessage(history) {
+    for (const message of history) {
+        if (message.role === "user") {
+            const trimmed = message.content.trim();
+            if (trimmed.length > 0) {
+                return trimmed;
+            }
+        }
+    }
+    return null;
+}
+async function createSessionFileFromHistory(history, now = new Date()) {
+    await (0, promises_1.mkdir)(SESSION_DIR, { recursive: true });
+    const firstUserMessage = getFirstUserMessage(history) ?? "";
+    const sessionName = slugifySessionNameFromMessage(firstUserMessage);
+    const path = (0, node_path_1.join)(SESSION_DIR, `${toSessionTimestamp(now)}_${sessionName}.md`);
+    return { path, sessionName };
+}
+async function writeSessionFile(options) {
+    const now = options.now ?? new Date();
+    const lines = [];
+    for (const message of options.history) {
+        if (message.role === "user") {
+            lines.push(`**${options.username}**: ${message.content}`);
+            continue;
+        }
+        if (message.role === "assistant") {
+            lines.push(`**Yips**: ${message.content}`);
+            continue;
+        }
+        lines.push(`*[System: ${message.content}]*`);
+    }
+    const body = [
+        "# Session Memory",
+        "",
+        `**Created**: ${now.toISOString()}`,
+        "**Type**: Ongoing Session",
+        "",
+        "## Conversation",
+        "",
+        ...lines,
+        "",
+        "---",
+        `*Last updated: ${now.toISOString()}*`,
+        ""
+    ].join("\n");
+    await (0, promises_1.writeFile)(options.path, body, "utf8");
+}
+async function listSessions(limit) {
+    try {
+        const entries = await (0, promises_1.readdir)(SESSION_DIR, { withFileTypes: true });
+        const sessionItems = entries
+            .filter((entry) => entry.isFile() && entry.name.toLowerCase().endsWith(".md"))
+            .map((entry) => {
+            const path = (0, node_path_1.join)(SESSION_DIR, entry.name);
+            const parsed = parseFileStem(path);
+            return {
+                path,
+                sessionName: parsed.sessionName,
+                timestamp: parsed.timestamp,
+                display: toDisplay(parsed.sessionName, parsed.timestamp)
+            };
+        })
+            .sort((a, b) => b.timestamp.valueOf() - a.timestamp.valueOf());
+        return typeof limit === "number" && limit > 0 ? sessionItems.slice(0, limit) : sessionItems;
+    }
+    catch {
+        return [];
+    }
+}
+async function loadSession(path) {
+    const content = await (0, promises_1.readFile)(path, "utf8");
+    const parsed = parseFileStem(path);
+    return {
+        history: parseConversation(content),
+        sessionName: parsed.sessionName,
+        path
+    };
+}

package/dist/spinner.js

@@ -0,0 +1,76 @@
+"use strict";
+/** Pulsing braille spinner with color oscillation. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PulsingSpinner = void 0;
+const colors_1 = require("./colors");
+const SPINNER_FRAMES = ["⠹", "⢸", "⣰", "⣤", "⣆", "⡇", "⠏", "⠛"];
+const FRAME_COUNT = SPINNER_FRAMES.length;
+const OSCILLATION_RATE = 2.0;
+const FRAME_INTERVAL_MS = 80;
+class PulsingSpinner {
+    label;
+    frameIndex;
+    startTime;
+    lastFrameTime;
+    active;
+    constructor(label = "Thinking...") {
+        this.label = label;
+        this.frameIndex = 0;
+        this.startTime = Date.now();
+        this.lastFrameTime = this.startTime;
+        this.active = false;
+    }
+    start(label) {
+        if (label !== undefined) {
+            this.label = label;
+        }
+        this.frameIndex = 0;
+        this.startTime = Date.now();
+        this.lastFrameTime = this.startTime;
+        this.active = true;
+    }
+    stop() {
+        this.active = false;
+    }
+    update(label) {
+        this.label = label;
+    }
+    isActive() {
+        return this.active;
+    }
+    getElapsed() {
+        return Math.floor((Date.now() - this.startTime) / 1000);
+    }
+    formatElapsed(seconds) {
+        const minutes = Math.floor(seconds / 60);
+        const remainder = seconds % 60;
+        if (minutes === 0) {
+            return `${remainder}s`;
+        }
+        return `${minutes}m ${remainder}s`;
+    }
+    render() {
+        const now = Date.now();
+        const elapsedSinceFrame = now - this.lastFrameTime;
+        if (elapsedSinceFrame >= FRAME_INTERVAL_MS) {
+            const frameSteps = Math.floor(elapsedSinceFrame / FRAME_INTERVAL_MS);
+            this.frameIndex = (this.frameIndex + frameSteps) % FRAME_COUNT;
+            this.lastFrameTime += frameSteps * FRAME_INTERVAL_MS;
+        }
+        const frame = SPINNER_FRAMES[this.frameIndex % FRAME_COUNT];
+        const elapsedSeconds = Math.max(0, (now - this.startTime) / 1000);
+        const elapsed = Math.floor(elapsedSeconds);
+        const t = (Math.sin(elapsedSeconds * OSCILLATION_RATE) + 1) / 2;
+        const color = (0, colors_1.interpolateColor)(colors_1.GRADIENT_PINK, colors_1.GRADIENT_YELLOW, t);
+        const timeText = this.formatElapsed(elapsed);
+        const spinnerChar = (0, colors_1.colorText)(frame, color);
+        const labelText = (0, colors_1.colorText)(this.label, color);
+        const suffix = (0, colors_1.colorText)(`(${timeText})`, color);
+        return `${spinnerChar} ${labelText} ${suffix}`;
+    }
+    static computeOscillationColor(elapsedSeconds) {
+        const t = (Math.sin(elapsedSeconds * OSCILLATION_RATE) + 1) / 2;
+        return (0, colors_1.interpolateColor)(colors_1.GRADIENT_PINK, colors_1.GRADIENT_YELLOW, t);
+    }
+}
+exports.PulsingSpinner = PulsingSpinner;

package/dist/title-box.js

@@ -0,0 +1,388 @@
+"use strict";
+/** Responsive title box using the yips-cli visual contract. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stripMarkup = stripMarkup;
+exports.renderTitleBox = renderTitleBox;
+exports.getLayoutMode = getLayoutMode;
+const colors_1 = require("./colors");
+const YIPS_LOGO = [
+    "██╗   ██╗██╗██████╗ ███████╗",
+    "╚██╗ ██╔╝██║██╔══██╗██╔════╝",
+    " ╚████╔╝ ██║██████╔╝███████╗",
+    "  ╚██╔╝  ██║██╔═══╝ ╚════██║",
+    "   ██║   ██║██║     ███████║",
+    "   ╚═╝   ╚═╝╚═╝     ╚══════╝"
+];
+const LOGO_WIDTH = 28;
+const TOP_TITLE = "Yips";
+const TOP_TITLE_FALLBACK = "Yips";
+const TOP_BORDER_MIN_WIDTH = 25;
+function getLayoutMode(width) {
+    if (width >= 80)
+        return "full";
+    if (width >= 60)
+        return "single";
+    if (width >= 45)
+        return "compact";
+    return "minimal";
+}
+function centerText(text, width) {
+    if (width <= 0)
+        return "";
+    if (text.length >= width)
+        return text.slice(0, width);
+    const leftPadding = Math.floor((width - text.length) / 2);
+    const rightPadding = width - text.length - leftPadding;
+    return `${" ".repeat(leftPadding)}${text}${" ".repeat(rightPadding)}`;
+}
+function fitText(text, width) {
+    if (width <= 0)
+        return "";
+    if (text.length >= width)
+        return text.slice(0, width);
+    return text.padEnd(width, " ");
+}
+function toSingleColor(char, progress) {
+    return (0, colors_1.colorChar)(char, (0, colors_1.interpolateColor)(colors_1.GRADIENT_PINK, colors_1.GRADIENT_YELLOW, progress));
+}
+function makeTopBorder(version, width) {
+    if (width <= 0)
+        return "";
+    const fallback = `╭${"─".repeat(Math.max(0, width - 2))}╮`;
+    if (width < TOP_BORDER_MIN_WIDTH) {
+        return (0, colors_1.horizontalGradient)(fallback, colors_1.GRADIENT_PINK, colors_1.GRADIENT_YELLOW);
+    }
+    let title = TOP_TITLE;
+    let titleLength = title.length + 1 + version.length;
+    let borderAvailable = width - titleLength - 7;
+    if (borderAvailable < 0) {
+        title = TOP_TITLE_FALLBACK;
+        titleLength = title.length + 1 + version.length;
+        borderAvailable = width - titleLength - 7;
+        if (borderAvailable < 0) {
+            return (0, colors_1.horizontalGradient)(fallback, colors_1.GRADIENT_PINK, colors_1.GRADIENT_YELLOW);
+        }
+    }
+    const pieces = [];
+    let position = 0;
+    const appendBorder = (segment) => {
+        for (const char of segment) {
+            const progress = position / Math.max(width - 1, 1);
+            pieces.push(toSingleColor(char, progress));
+            position += 1;
+        }
+    };
+    appendBorder("╭─── ");
+    pieces.push("\u001b[1m");
+    for (let i = 0; i < title.length; i++) {
+        const progress = i / Math.max(title.length - 1, 1);
+        pieces.push(toSingleColor(title[i], progress));
+        position += 1;
+    }
+    pieces.push(" ");
+    position += 1;
+    pieces.push((0, colors_1.colorText)(version, colors_1.GRADIENT_BLUE));
+    position += version.length;
+    pieces.push("\u001b[22m");
+    const closing = ` ${"─".repeat(Math.max(0, borderAvailable))}╮`;
+    appendBorder(closing);
+    return pieces.join("");
+}
+/** Strip ANSI and legacy terminal-kit markup sequences for test/plain rendering. */
+function stripMarkup(text) {
+    return (0, colors_1.stripAnsi)(text).replace(/\^\[#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{6})\]|\^#[0-9a-fA-F]{6}|\^:/g, "");
+}
+function makeBottomBorder(sessionName, width) {
+    if (width <= 0)
+        return "";
+    const borderChars = Array.from({ length: Math.max(0, width - 2) }, () => "─");
+    const trimmedSessionName = sessionName.trim();
+    if (trimmedSessionName.length === 0) {
+        return (0, colors_1.horizontalGradient)(`╰${borderChars.join("")}╯`, colors_1.GRADIENT_PINK, colors_1.GRADIENT_YELLOW);
+    }
+    const displayName = ` ${trimmedSessionName.replace(/_/g, " ")} `;
+    if (displayName.length <= borderChars.length) {
+        const start = Math.floor((borderChars.length - displayName.length) / 2);
+        for (let i = 0; i < displayName.length; i++) {
+            borderChars[start + i] = displayName[i];
+        }
+    }
+    return (0, colors_1.horizontalGradient)(`╰${borderChars.join("")}╯`, colors_1.GRADIENT_PINK, colors_1.GRADIENT_YELLOW);
+}
+function buildModelInfo(backend, model, tokenUsage) {
+    const trimmedModel = model.trim();
+    if (trimmedModel.length === 0) {
+        return backend;
+    }
+    const parts = [backend, trimmedModel];
+    const usage = tokenUsage.trim();
+    if (usage.length > 0) {
+        parts.push(usage);
+    }
+    return parts.join(" · ");
+}
+function padLine(markup, plain, width) {
+    const clippedPlain = fitText(plain, width);
+    if (plain.length > width) {
+        return clippedPlain;
+    }
+    const padding = " ".repeat(Math.max(0, width - plain.length));
+    return `${markup}${padding}`;
+}
+function makeSingleRow(contentMarkup, contentPlain, width) {
+    const innerWidth = Math.max(0, width - 2);
+    const leftBorder = (0, colors_1.horizontalGradient)("│", colors_1.GRADIENT_PINK, colors_1.GRADIENT_PINK);
+    const rightBorder = (0, colors_1.horizontalGradient)("│", colors_1.GRADIENT_YELLOW, colors_1.GRADIENT_YELLOW);
+    return `${leftBorder}${padLine(contentMarkup, contentPlain, innerWidth)}${rightBorder}`;
+}
+function styleCenteredText(text, width, style) {
+    const centered = centerText(text, width);
+    switch (style) {
+        case "gradient":
+            return {
+                markup: (0, colors_1.horizontalGradient)(centered, colors_1.GRADIENT_PINK, colors_1.GRADIENT_YELLOW),
+                plain: centered
+            };
+        case "blue":
+            return { markup: (0, colors_1.colorText)(centered, colors_1.GRADIENT_BLUE), plain: centered };
+        case "pink":
+            return { markup: (0, colors_1.colorText)(centered, colors_1.INPUT_PINK), plain: centered };
+        case "dim":
+            return { markup: (0, colors_1.colorText)(centered, colors_1.DIM_GRAY), plain: centered };
+        case "plain":
+            return { markup: centered, plain: centered };
+    }
+}
+function styleCenteredTextWithGradientSpan(text, width) {
+    if (width <= 0)
+        return { markup: "", plain: "" };
+    const clipped = text.slice(0, width);
+    if (clipped.length >= width) {
+        return {
+            markup: (0, colors_1.horizontalGradient)(clipped, colors_1.GRADIENT_PINK, colors_1.GRADIENT_YELLOW),
+            plain: clipped
+        };
+    }
+    const leftPadding = Math.floor((width - clipped.length) / 2);
+    const rightPadding = width - clipped.length - leftPadding;
+    return {
+        markup: `${" ".repeat(leftPadding)}${(0, colors_1.horizontalGradient)(clipped, colors_1.GRADIENT_PINK, colors_1.GRADIENT_YELLOW)}${" ".repeat(rightPadding)}`,
+        plain: `${" ".repeat(leftPadding)}${clipped}${" ".repeat(rightPadding)}`
+    };
+}
+function withBold(row) {
+    if (row.markup.length === 0)
+        return row;
+    return { markup: `\u001b[1m${row.markup}\u001b[22m`, plain: row.plain };
+}
+function styleLeftText(text, width, style) {
+    const clipped = text.slice(0, Math.max(0, width));
+    const padded = fitText(clipped, width);
+    switch (style) {
+        case "gradient":
+            if (clipped.length === 0)
+                return { markup: padded, plain: padded };
+            return {
+                markup: `${(0, colors_1.horizontalGradient)(clipped, colors_1.GRADIENT_PINK, colors_1.GRADIENT_YELLOW)}${" ".repeat(Math.max(0, width - clipped.length))}`,
+                plain: padded
+            };
+        case "blue":
+            if (clipped.length === 0)
+                return { markup: padded, plain: padded };
+            return {
+                markup: `${(0, colors_1.colorText)(clipped, colors_1.GRADIENT_BLUE)}${" ".repeat(Math.max(0, width - clipped.length))}`,
+                plain: padded
+            };
+        case "white":
+            if (clipped.length === 0)
+                return { markup: padded, plain: padded };
+            return {
+                markup: `${(0, colors_1.colorText)(clipped, { r: 255, g: 255, b: 255 })}${" ".repeat(Math.max(0, width - clipped.length))}`,
+                plain: padded
+            };
+        case "dim":
+            if (clipped.length === 0)
+                return { markup: padded, plain: padded };
+            return {
+                markup: `${(0, colors_1.colorText)(clipped, colors_1.DIM_GRAY)}${" ".repeat(Math.max(0, width - clipped.length))}`,
+                plain: padded
+            };
+        case "plain":
+            return { markup: padded, plain: padded };
+    }
+}
+function styleHighlightedText(text, width) {
+    const clipped = text.slice(0, Math.max(0, width));
+    const padded = fitText(clipped, width);
+    if (clipped.length === 0)
+        return { markup: padded, plain: padded };
+    return {
+        markup: `\u001b[1m${(0, colors_1.colorText)(clipped, colors_1.INPUT_PINK)}\u001b[22m${" ".repeat(Math.max(0, width - clipped.length))}`,
+        plain: padded
+    };
+}
+function styleLeftTextGlobalGradient(text, width, totalWidth, startColumn) {
+    const clipped = text.slice(0, Math.max(0, width));
+    const padded = fitText(clipped, width);
+    if (clipped.length === 0)
+        return { markup: padded, plain: padded };
+    const maxColumn = Math.max(totalWidth - 1, 1);
+    const startColor = (0, colors_1.interpolateColor)(colors_1.GRADIENT_PINK, colors_1.GRADIENT_YELLOW, Math.max(0, Math.min(1, startColumn / maxColumn)));
+    const endColumn = startColumn + Math.max(clipped.length - 1, 0);
+    const endColor = (0, colors_1.interpolateColor)(colors_1.GRADIENT_PINK, colors_1.GRADIENT_YELLOW, Math.max(0, Math.min(1, endColumn / maxColumn)));
+    return {
+        markup: `${(0, colors_1.horizontalGradient)(clipped, startColor, endColor)}${" ".repeat(Math.max(0, width - clipped.length))}`,
+        plain: padded
+    };
+}
+function centerLogoLine(logoMarkup, logoPlain, width) {
+    const paddingLeft = Math.max(0, Math.floor((width - logoPlain.length) / 2));
+    const paddingRight = Math.max(0, width - logoPlain.length - paddingLeft);
+    return {
+        markup: `${" ".repeat(paddingLeft)}${logoMarkup}${" ".repeat(paddingRight)}`,
+        plain: `${" ".repeat(paddingLeft)}${logoPlain}${" ".repeat(paddingRight)}`
+    };
+}
+function renderSingleColumn(options, mode) {
+    const { width, version, username, backend, model, tokenUsage, cwd, sessionName } = options;
+    const innerWidth = Math.max(0, width - 2);
+    const lines = [];
+    const modelInfo = buildModelInfo(backend, model, tokenUsage);
+    const gradientLogo = (0, colors_1.rowMajorGradient)(YIPS_LOGO, colors_1.GRADIENT_PINK, colors_1.GRADIENT_YELLOW);
+    const showLogo = innerWidth >= LOGO_WIDTH;
+    lines.push(makeTopBorder(version, width));
+    if (mode === "minimal") {
+        const minimalRows = [];
+        minimalRows.push(styleCenteredText("", innerWidth, "plain"));
+        if (showLogo) {
+            for (let i = 0; i < YIPS_LOGO.length; i++) {
+                minimalRows.push(centerLogoLine(gradientLogo[i] ?? "", YIPS_LOGO[i] ?? "", innerWidth));
+            }
+        }
+        else {
+            minimalRows.push(styleCenteredText("YIPS", innerWidth, "gradient"));
+        }
+        minimalRows.push(styleCenteredText(modelInfo, innerWidth, "blue"));
+        minimalRows.push(styleCenteredText("", innerWidth, "plain"));
+        for (const row of minimalRows) {
+            lines.push(makeSingleRow(row.markup, row.plain, width));
+        }
+        lines.push(makeBottomBorder(sessionName, width));
+        return lines;
+    }
+    const rows = [];
+    rows.push(styleCenteredText("", innerWidth, "plain"));
+    rows.push(mode === "single"
+        ? withBold(styleCenteredTextWithGradientSpan(`Welcome back ${username}!`, innerWidth))
+        : styleCenteredTextWithGradientSpan(`Hi ${username}!`, innerWidth));
+    rows.push(styleCenteredText("", innerWidth, "plain"));
+    if (showLogo) {
+        for (let i = 0; i < YIPS_LOGO.length; i++) {
+            rows.push(centerLogoLine(gradientLogo[i] ?? "", YIPS_LOGO[i] ?? "", innerWidth));
+        }
+    }
+    else {
+        rows.push(styleCenteredText("YIPS", innerWidth, "gradient"));
+    }
+    rows.push(styleCenteredText(modelInfo, innerWidth, "blue"));
+    if (mode === "single") {
+        rows.push(styleCenteredTextWithGradientSpan(cwd, innerWidth));
+    }
+    rows.push(styleCenteredText("", innerWidth, "plain"));
+    for (const row of rows) {
+        lines.push(makeSingleRow(row.markup, row.plain, width));
+    }
+    lines.push(makeBottomBorder(sessionName, width));
+    return lines;
+}
+function renderFull(options) {
+    const { width, version, username, backend, model, tokenUsage, cwd, sessionName, recentActivity = [], sessionSelection } = options;
+    const lines = [];
+    const modelInfo = buildModelInfo(backend, model, tokenUsage);
+    const availableWidth = Math.max(0, width - 3);
+    const leftWidth = Math.max(Math.floor(availableWidth * 0.45), 30);
+    const rightWidth = Math.max(0, availableWidth - leftWidth);
+    const middleProgress = (leftWidth + 1) / Math.max(width - 1, 1);
+    const middleBorderColor = (0, colors_1.interpolateColor)(colors_1.GRADIENT_PINK, colors_1.GRADIENT_YELLOW, middleProgress);
+    const leftBorder = (0, colors_1.horizontalGradient)("│", colors_1.GRADIENT_PINK, colors_1.GRADIENT_PINK);
+    const middleBorder = (0, colors_1.colorText)("│", middleBorderColor);
+    const rightBorder = (0, colors_1.horizontalGradient)("│", colors_1.GRADIENT_YELLOW, colors_1.GRADIENT_YELLOW);
+    const gradientLogo = (0, colors_1.rowMajorGradient)(YIPS_LOGO, colors_1.GRADIENT_PINK, colors_1.GRADIENT_YELLOW);
+    const rightStartColumn = leftWidth + 2;
+    const leftRows = [
+        styleCenteredText("", leftWidth, "plain"),
+        withBold(styleCenteredTextWithGradientSpan(`Welcome back ${username}!`, leftWidth)),
+        styleCenteredText("", leftWidth, "plain")
+    ];
+    for (let i = 0; i < YIPS_LOGO.length; i++) {
+        leftRows.push(centerLogoLine(gradientLogo[i] ?? "", YIPS_LOGO[i] ?? "", leftWidth));
+    }
+    leftRows.push(styleCenteredText(modelInfo, leftWidth, "blue"));
+    leftRows.push(styleCenteredTextWithGradientSpan(cwd, leftWidth));
+    leftRows.push(styleCenteredText("", leftWidth, "plain"));
+    const rightRows = [
+        withBold(styleLeftTextGlobalGradient("Tips for getting started:", rightWidth, width, rightStartColumn)),
+        styleLeftTextGlobalGradient("- Ask questions, edit files, or run commands.", rightWidth, width, rightStartColumn),
+        styleLeftTextGlobalGradient("- Be specific for the best results.", rightWidth, width, rightStartColumn),
+        styleLeftTextGlobalGradient("- /help for more information.", rightWidth, width, rightStartColumn),
+        styleLeftText("", rightWidth, "plain"),
+        styleLeftTextGlobalGradient("─".repeat(Math.max(0, rightWidth)), rightWidth, width, rightStartColumn),
+        withBold(styleLeftText("Recent activity", rightWidth, "white"))
+    ];
+    const activityItems = recentActivity.length > 0 ? recentActivity : ["No recent activity yet."];
+    if (sessionSelection?.active) {
+        const maxSlots = 5;
+        const safeSelected = Math.max(0, Math.min(sessionSelection.selectedIndex, activityItems.length - 1));
+        const start = Math.max(0, Math.min(safeSelected - Math.floor(maxSlots / 2), Math.max(0, activityItems.length - maxSlots)));
+        const visible = activityItems.slice(start, start + maxSlots);
+        for (let i = 0; i < visible.length; i++) {
+            const actualIndex = start + i;
+            const item = visible[i] ?? "";
+            if (actualIndex === safeSelected) {
+                rightRows.push(styleHighlightedText(`> ${item}`, rightWidth));
+            }
+            else {
+                rightRows.push(styleLeftText(`  ${item}`, rightWidth, "dim"));
+            }
+        }
+    }
+    else {
+        for (const item of activityItems.slice(0, 5)) {
+            rightRows.push(styleLeftText(item, rightWidth, "dim"));
+        }
+    }
+    while (rightRows.length < leftRows.length) {
+        rightRows.push(styleLeftText("", rightWidth, "plain"));
+    }
+    lines.push(makeTopBorder(version, width));
+    const maxRows = Math.max(leftRows.length, rightRows.length);
+    for (let row = 0; row < maxRows; row++) {
+        const left = leftRows[row] ?? styleLeftText("", leftWidth, "plain");
+        const right = rightRows[row] ?? styleLeftText("", rightWidth, "plain");
+        lines.push(`${leftBorder}${padLine(left.markup, left.plain, leftWidth)}${middleBorder}${padLine(right.markup, right.plain, rightWidth)}${rightBorder}`);
+    }
+    lines.push(makeBottomBorder(sessionName, width));
+    return lines;
+}
+function renderCompact(options) {
+    return renderSingleColumn(options, "compact");
+}
+function renderMinimal(options) {
+    return renderSingleColumn(options, "minimal");
+}
+function renderSingle(options) {
+    return renderSingleColumn(options, "single");
+}
+function renderTitleBox(options) {
+    const mode = getLayoutMode(options.width);
+    switch (mode) {
+        case "full":
+            return renderFull(options);
+        case "single":
+            return renderSingle(options);
+        case "compact":
+            return renderCompact(options);
+        case "minimal":
+            return renderMinimal(options);
+    }
+}