praxis-agent 0.43.0 → 0.44.0

package/dist/cli/provider-auth-command.js

@@ -0,0 +1,249 @@
+import { ProviderCredentialVault, } from '../persistence/provider-credential-vault.js';
+import { deviceLoginWithCodexOAuth, loginWithCodexOAuth, } from '../providers/codex-oauth.js';
+import { resolveProviderTarget } from '../providers/provider-settings.js';
+import { resolveDataPlaneRoot } from '../persistence/data-plane.js';
+const IDENTIFIER = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u;
+const MAX_SECRET_BYTES = 64 * 1024;
+function fail(message) {
+    throw new Error(message);
+}
+function identifier(value, label) {
+    if (!IDENTIFIER.test(value))
+        fail(`${label} must match [A-Za-z0-9][A-Za-z0-9._-]{0,127}`);
+    return value;
+}
+function parse(args, options) {
+    if (args[0] === 'auth')
+        args = args.slice(1);
+    const action = args[0];
+    if (action !== 'status' &&
+        action !== 'set-key' &&
+        action !== 'login' &&
+        action !== 'logout') {
+        fail('auth requires status, set-key, login, or logout');
+    }
+    let provider;
+    let profile;
+    let json = options.json ?? false;
+    let noBrowser = options.noBrowser ?? false;
+    let device = options.device ?? false;
+    for (let index = 1; index < args.length; index += 1) {
+        const value = args[index];
+        if (value === '--json') {
+            if (json)
+                fail('--json may only be specified once');
+            json = true;
+            continue;
+        }
+        if (value === '--device') {
+            if (device)
+                fail('--device may only be specified once');
+            device = true;
+            continue;
+        }
+        if (value === '--no-browser') {
+            if (noBrowser)
+                fail('--no-browser may only be specified once');
+            noBrowser = true;
+            continue;
+        }
+        if (value === '--profile' || value?.startsWith('--profile=')) {
+            if (profile !== undefined)
+                fail('--profile may only be specified once');
+            const selected = value === '--profile' ? args[++index] : value.slice('--profile='.length);
+            if (typeof selected !== 'string' || selected.length === 0)
+                fail('--profile requires a value');
+            profile = identifier(selected, 'profile');
+            continue;
+        }
+        if (value?.startsWith('-'))
+            fail(`Unknown option: ${value}`);
+        if (typeof value !== 'string')
+            fail(`Unexpected operand for auth ${action}`);
+        if (provider !== undefined)
+            fail(`Unexpected operand for auth ${action}: ${value}`);
+        provider = identifier(value, 'provider');
+    }
+    if (options.profile !== undefined &&
+        profile !== undefined &&
+        options.profile !== profile)
+        fail('auth --profile conflicts with the selected profile');
+    if (options.providerProfile !== undefined &&
+        profile !== undefined &&
+        options.providerProfile !== profile)
+        fail('auth --profile conflicts with --provider-profile');
+    if (options.profile !== undefined &&
+        options.providerProfile !== undefined &&
+        options.profile !== options.providerProfile)
+        fail('auth --profile conflicts with --provider-profile');
+    const selectedProfile = profile ?? options.profile ?? options.providerProfile;
+    profile =
+        action === 'status' && selectedProfile === undefined
+            ? undefined
+            : identifier(selectedProfile ?? 'default', 'profile');
+    if (action === 'status' && provider === undefined) {
+        // status accepts zero or one provider operand.
+    }
+    else if (action !== 'status' && provider === undefined) {
+        fail(`auth ${action} requires a provider`);
+    }
+    if (action === 'set-key' && provider === 'openai-codex')
+        fail('auth set-key does not support openai-codex; use auth login');
+    if (action === 'login' && provider !== 'openai-codex')
+        fail('auth login only supports openai-codex');
+    if (action !== 'login' && (device || noBrowser))
+        fail('--device and --no-browser are only valid with auth login');
+    return {
+        action,
+        ...(provider === undefined ? {} : { provider }),
+        ...(profile === undefined ? {} : { profile }),
+        json,
+        device,
+        noBrowser,
+    };
+}
+function defaultVault(options) {
+    const environment = options.environment ?? process.env;
+    const vaultOptions = {
+        configRoot: options.configRoot ?? resolveDataPlaneRoot({ environment }),
+        environment,
+    };
+    return new ProviderCredentialVault(vaultOptions);
+}
+async function assertCodexLoginEnabled(options, profileId) {
+    const environment = options.environment ?? process.env;
+    await resolveProviderTarget({
+        configRoot: options.configRoot ?? resolveDataPlaneRoot({ environment }),
+        cwd: options.cwd ?? process.cwd(),
+        environment,
+        provider: 'openai-codex',
+        profile: profileId,
+        model: 'codex-authentication',
+    });
+}
+function json(io, value) {
+    io.stdout(`${JSON.stringify(value)}\n`);
+}
+function text(io, message) {
+    io.stdout(`${message}\n`);
+}
+function metadata(value) {
+    return {
+        provider: value.key.providerId,
+        profile: value.key.profileId,
+        type: value.type,
+        updatedAt: value.updatedAt,
+        ...(value.expiresAt === undefined
+            ? {}
+            : { expiry: value.expiresAt > Date.now() ? 'valid' : 'expired' }),
+    };
+}
+function sortedMetadata(records, provider, profile) {
+    return records
+        .filter((record) => (provider === undefined || record.key.providerId === provider) &&
+        (profile === undefined || record.key.profileId === profile))
+        .sort((left, right) => {
+        const providerOrder = left.key.providerId.localeCompare(right.key.providerId);
+        return (providerOrder || left.key.profileId.localeCompare(right.key.profileId));
+    })
+        .map(metadata);
+}
+export function secretLine(value) {
+    if (Buffer.byteLength(value, 'utf8') > MAX_SECRET_BYTES)
+        fail('Credential exceeds the 64 KiB limit');
+    const stripped = value.endsWith('\r\n')
+        ? value.slice(0, -2)
+        : value.endsWith('\r') || value.endsWith('\n')
+            ? value.slice(0, -1)
+            : value;
+    if (/[\r\n]/u.test(stripped) || stripped.trim().length === 0)
+        fail('Credential must be exactly one non-blank line');
+    return stripped;
+}
+export async function executeProviderAuthCommand(args, options) {
+    const parsed = parse(args, options);
+    const vault = options.vault ?? defaultVault(options);
+    if (parsed.action === 'status') {
+        const credentials = sortedMetadata(await vault.list(), parsed.provider, parsed.profile);
+        if (parsed.json) {
+            json(options.io, { type: 'provider-auth-status', credentials });
+        }
+        else if (credentials.length === 0) {
+            text(options.io, 'No provider credentials configured.');
+        }
+        else {
+            text(options.io, credentials
+                .map((credential) => `${credential.provider}/${credential.profile}: ${credential.type}${credential.expiry === undefined ? '' : ` (${credential.expiry})`}`)
+                .join('\n'));
+        }
+        return 0;
+    }
+    const provider = parsed.provider;
+    if (provider === undefined)
+        fail(`auth ${parsed.action} requires a provider`);
+    const key = {
+        providerId: provider,
+        profileId: parsed.profile ?? 'default',
+    };
+    if (parsed.action === 'set-key') {
+        if (!options.io.readSecret)
+            fail('auth set-key requires an interactive secret reader');
+        const secret = secretLine(await options.io.readSecret('API key: ', options.signal));
+        await vault.modify(key, () => ({ type: 'api-key', secret }));
+        const result = {
+            provider: key.providerId,
+            profile: key.profileId,
+            type: 'api-key',
+        };
+        if (parsed.json)
+            json(options.io, result);
+        else
+            text(options.io, `Stored api-key credential for ${key.providerId}/${key.profileId}.`);
+        return 0;
+    }
+    if (parsed.action === 'logout') {
+        const existing = await vault.read(key);
+        if (existing !== undefined)
+            await vault.delete(key);
+        const result = {
+            provider: key.providerId,
+            profile: key.profileId,
+            deleted: true,
+        };
+        if (parsed.json)
+            json(options.io, result);
+        else
+            text(options.io, `Logged out ${key.providerId}/${key.profileId}.`);
+        return 0;
+    }
+    await (options.assertCodexLoginEnabled ??
+        ((profileId) => assertCodexLoginEnabled(options, profileId)))(key.profileId);
+    const loginOptions = {
+        profileId: key.profileId,
+        vault: createCodexOAuthVault(vault),
+        ...(options.signal === undefined ? {} : { signal: options.signal }),
+        ...(parsed.noBrowser ? { noBrowser: true } : {}),
+        write: (message) => options.io.stderr?.(message),
+    };
+    const login = parsed.device
+        ? (options.deviceLoginWithCodexOAuth ?? deviceLoginWithCodexOAuth)
+        : (options.loginWithCodexOAuth ?? loginWithCodexOAuth);
+    await login(loginOptions);
+    const result = {
+        provider: key.providerId,
+        profile: key.profileId,
+        type: 'oauth',
+    };
+    if (parsed.json)
+        json(options.io, result);
+    else
+        text(options.io, `Logged in ${key.providerId}/${key.profileId}.`);
+    return 0;
+}
+function createCodexOAuthVault(vault) {
+    return {
+        read: (key) => vault.read(key),
+        modify: (key, callback) => vault.modify(key, async (current) => callback(current)),
+    };
+}
+//# sourceMappingURL=provider-auth-command.js.map

package/dist/cli/tui/ansi-frame-renderer.d.ts

@@ -1,3 +1,4 @@
+import type { QuietFrameCursor } from './quiet-frame.js';
 import type { TuiRow, TuiTextRole } from './tui-row-ir.js';
 export interface AnsiFrameWriter {
     write(chunk: string): void;
@@ -6,6 +7,7 @@ export interface AnsiFrame {
     readonly columns: number;
     readonly rows: number;
     readonly lines: readonly TuiRow[];
+    readonly cursor?: QuietFrameCursor;
 }
 export interface AnsiFullscreenRendererOptions {
     readonly writer: AnsiFrameWriter;

package/dist/cli/tui/ansi-frame-renderer.js

@@ -1,4 +1,5 @@
 import { stripVTControlCharacters } from 'node:util';
+import { terminalGraphemes, terminalGraphemeWidth, terminalTextWidth, } from './transcript-viewport.js';
 const ALTERNATE_SCREEN_ENTER = '\u001b[?1049h';
 const ALTERNATE_SCREEN_LEAVE = '\u001b[?1049l';
 const HIDE_CURSOR = '\u001b[?25l';
@@ -19,22 +20,44 @@ function validateFrame(frame) {
     if (!Array.isArray(frame.lines)) {
         throw new TypeError('ANSI frame lines must be an array');
     }
+    if (frame.cursor !== undefined) {
+        if (frame.cursor === null ||
+            typeof frame.cursor !== 'object' ||
+            typeof frame.cursor.rowKey !== 'string' ||
+            frame.cursor.rowKey.length === 0 ||
+            !Number.isFinite(frame.cursor.column) ||
+            !Number.isInteger(frame.cursor.column) ||
+            frame.cursor.column < 0) {
+            throw new TypeError('ANSI frame cursor must have a non-empty row key and non-negative integer column');
+        }
+    }
 }
 function renderLine(row, styles, columns) {
     const segments = row.segments.map((segment) => ({
         text: stripVTControlCharacters(segment.text).replace(/[\r\n]/gu, ''),
         role: segment.role,
     }));
-    const visibleLength = segments.reduce((length, segment) => length + Array.from(segment.text).length, 0);
+    const visibleLength = segments.reduce((length, segment) => length + terminalTextWidth(segment.text), 0);
     const wasTruncated = visibleLength > columns;
     const targetLength = wasTruncated ? Math.max(0, columns - 1) : columns;
     let remaining = targetLength;
     let line = '';
+    let stopped = false;
     for (const segment of segments) {
-        if (remaining === 0)
+        if (remaining === 0 || stopped)
             break;
-        const text = Array.from(segment.text).slice(0, remaining).join('');
-        remaining -= Array.from(text).length;
+        let text = '';
+        for (const grapheme of terminalGraphemes(segment.text)) {
+            const width = terminalGraphemeWidth(grapheme);
+            if (remaining < width) {
+                stopped = true;
+                break;
+            }
+            text += grapheme;
+            remaining -= width;
+        }
+        if (text.length === 0)
+            continue;
         const style = styles?.[segment.role];
         line += style === undefined ? text : `${style}${text}${RESET}`;
     }
@@ -50,6 +73,7 @@ export class AnsiFullscreenRenderer {
     #styles;
     #mounted = false;
     #previousLines = [];
+    #previousCursor;
     constructor(options) {
         this.#writer = options.writer;
         this.#synchronizedOutput = options.synchronizedOutput === true;
@@ -64,11 +88,50 @@ export class AnsiFullscreenRenderer {
     mount() {
         if (this.#mounted)
             return;
-        this.#writer.write(ALTERNATE_SCREEN_ENTER);
-        this.#writer.write(HIDE_CURSOR);
-        if (this.#synchronizedOutput)
-            this.#writer.write(SYNCHRONIZED_BEGIN);
-        this.#mounted = true;
+        let alternateScreenEntered = false;
+        let cursorHidden = false;
+        let synchronizedOutputBegun = false;
+        try {
+            alternateScreenEntered = true;
+            this.#writer.write(ALTERNATE_SCREEN_ENTER);
+            cursorHidden = true;
+            this.#writer.write(HIDE_CURSOR);
+            if (this.#synchronizedOutput) {
+                synchronizedOutputBegun = true;
+                this.#writer.write(SYNCHRONIZED_BEGIN);
+            }
+            this.#mounted = true;
+        }
+        catch (error) {
+            this.#mounted = false;
+            this.#previousLines = [];
+            this.#previousCursor = undefined;
+            if (synchronizedOutputBegun) {
+                try {
+                    this.#writer.write(SYNCHRONIZED_END);
+                }
+                catch {
+                    // Rollback must continue if one restoration write fails.
+                }
+            }
+            if (cursorHidden) {
+                try {
+                    this.#writer.write(SHOW_CURSOR);
+                }
+                catch {
+                    // Rollback must continue if one restoration write fails.
+                }
+            }
+            if (alternateScreenEntered) {
+                try {
+                    this.#writer.write(ALTERNATE_SCREEN_LEAVE);
+                }
+                catch {
+                    // Rollback must continue if one restoration write fails.
+                }
+            }
+            throw error;
+        }
     }
     draw(frame) {
         if (!this.#mounted)
@@ -78,24 +141,48 @@ export class AnsiFullscreenRenderer {
         const previousLines = this.#previousLines;
         const changed = lines.length !== previousLines.length ||
             lines.some((line, index) => line !== previousLines[index]);
-        if (!changed)
+        const cursorRow = frame.cursor
+            ? frame.lines.findIndex((row) => row.key === frame.cursor?.rowKey)
+            : -1;
+        const nextCursor = cursorRow >= 0 && frame.cursor !== undefined
+            ? {
+                rowKey: frame.cursor.rowKey,
+                column: Math.min(frame.cursor.column, frame.columns - 1),
+                row: cursorRow,
+            }
+            : undefined;
+        const cursorChanged = nextCursor?.rowKey !== this.#previousCursor?.rowKey ||
+            nextCursor?.column !== this.#previousCursor?.column ||
+            nextCursor?.row !== this.#previousCursor?.row;
+        if (!changed && !cursorChanged)
             return;
         if (this.#synchronizedOutput)
             this.#writer.write(SYNCHRONIZED_BEGIN);
         try {
-            const commonLength = Math.max(lines.length, previousLines.length);
-            for (let index = 0; index < commonLength; index += 1) {
-                const line = lines[index];
-                if (line !== undefined) {
-                    if (line === previousLines[index])
-                        continue;
-                    this.#writer.write(`\u001b[${index + 1};1H\u001b[2K${line}`);
-                }
-                else {
-                    this.#writer.write(`\u001b[${index + 1};1H\u001b[2K`);
+            if (changed) {
+                if (this.#previousCursor !== undefined || nextCursor !== undefined)
+                    this.#writer.write(HIDE_CURSOR);
+                const commonLength = Math.max(lines.length, previousLines.length);
+                for (let index = 0; index < commonLength; index += 1) {
+                    const line = lines[index];
+                    if (line !== undefined) {
+                        if (line === previousLines[index])
+                            continue;
+                        this.#writer.write(`\u001b[${index + 1};1H\u001b[2K${line}`);
+                    }
+                    else {
+                        this.#writer.write(`\u001b[${index + 1};1H\u001b[2K`);
+                    }
                 }
+                this.#previousLines = lines;
+            }
+            if (nextCursor !== undefined) {
+                this.#writer.write(`\u001b[${cursorRow + 1};${nextCursor.column + 1}H`);
+                this.#writer.write(SHOW_CURSOR);
             }
-            this.#previousLines = lines;
+            else if (this.#previousCursor !== undefined)
+                this.#writer.write(HIDE_CURSOR);
+            this.#previousCursor = nextCursor;
         }
         finally {
             if (this.#synchronizedOutput)
@@ -114,6 +201,7 @@ export class AnsiFullscreenRenderer {
         finally {
             this.#mounted = false;
             this.#previousLines = [];
+            this.#previousCursor = undefined;
         }
     }
 }

package/dist/cli/tui/ansi-surface.d.ts

@@ -1,26 +1,10 @@
 import { type AnsiFrame } from './ansi-frame-renderer.js';
-import type { TuiScreenModel } from './tui-screen-model.js';
-export interface TuiAnsiSurfaceProps {
-    screen: TuiScreenModel;
-    width: number;
-    rows: number | undefined;
-    input: string;
-    busy: boolean;
-    status: string;
-    screenReader?: boolean;
-    display?: {
-        cwd: string;
-        model?: string;
-        effort?: string;
-        permissionMode?: string;
-        version?: string;
-    };
-    sessionLabel?: string;
-    cursor?: number;
-    onError: (error: unknown) => void;
+import type { QuietFrame } from './quiet-frame.js';
+export interface TuiAnsiSurfaceFrameProps {
+    readonly frame: QuietFrame;
+    readonly onError: (error: unknown) => void;
 }
-/** ANSI mode is intentionally limited to the plain conversation surface. */
-export declare function supportsAnsiSurface(screen: TuiScreenModel): boolean;
-export declare function projectAnsiSurfaceFrame(props: TuiAnsiSurfaceProps): AnsiFrame;
+export type TuiAnsiSurfaceProps = TuiAnsiSurfaceFrameProps;
+export declare function projectAnsiQuietFrame(frame: QuietFrame): AnsiFrame;
 export declare function TuiAnsiSurface(props: TuiAnsiSurfaceProps): null;
 //# sourceMappingURL=ansi-surface.d.ts.map

package/dist/cli/tui/ansi-surface.js

@@ -3,132 +3,12 @@ import { useStdout } from 'ink';
 import { AnsiFullscreenRenderer, } from './ansi-frame-renderer.js';
 import { resolveAnsiTextStyles } from './ansi-theme.js';
 import { useTuiTheme } from './theme.js';
-// Keep line breaks long enough for active stream projection to split them;
-// every emitted row is still guaranteed to contain no line breaks.
-function isUnsafeControl(character) {
-    const codePoint = character.codePointAt(0) ?? 0;
-    return ((codePoint >= 0 && codePoint <= 9) ||
-        codePoint === 11 ||
-        codePoint === 12 ||
-        (codePoint >= 14 && codePoint <= 31) ||
-        codePoint === 127);
-}
-function safeText(value) {
-    return typeof value === 'string'
-        ? Array.from(value)
-            .filter((character) => !isUnsafeControl(character))
-            .join('')
-        : '';
-}
-function row(key, text, role = 'body') {
-    return {
-        key,
-        segments: [{ text: safeText(text) || ' ', role }],
-        height: 1,
-        source: key,
-    };
-}
-function activeRows(key, text, role = 'body') {
-    return safeText(text)
-        .replace(/\r\n?/gu, '\n')
-        .split('\n')
-        .map((line, index) => row(`${key}:${index}`, line, role));
-}
-function headerRows(props) {
-    const display = props.display;
-    const identity = `Praxis${display?.version ? ` ${safeText(display.version)}` : ''}${props.sessionLabel ? ` · session ${safeText(props.sessionLabel)}` : ''}`;
-    const metadata = [
-        display?.cwd ? `cwd ${safeText(display.cwd).slice(0, 80)}` : '',
-        display?.model ? `model ${safeText(display.model).slice(0, 40)}` : '',
-        display?.effort ? `effort ${safeText(display.effort).slice(0, 20)}` : '',
-        display?.permissionMode
-            ? `permissions ${safeText(display.permissionMode).slice(0, 30)}`
-            : '',
-    ]
-        .filter(Boolean)
-        .join(' · ');
-    return [
-        row('ansi:header:identity', identity, 'heading'),
-        row('ansi:header:context', metadata || 'Ready', 'muted'),
-    ];
-}
-function summarize(value, depth = 0) {
-    if (depth > 1 || value === null || typeof value !== 'object')
-        return [];
-    const result = [];
-    for (const [key, item] of Object.entries(value)) {
-        if (typeof item === 'string' && item.length > 0) {
-            result.push(`${key}: ${safeText(item).slice(0, 120)}`);
-        }
-        else if (Array.isArray(item)) {
-            const strings = item.filter((entry) => typeof entry === 'string');
-            if (strings.length > 0)
-                result.push(`${key}: ${strings.slice(0, 4).map(safeText).join(', ')}`);
-        }
-        else if (typeof item === 'object' && item !== null) {
-            result.push(...summarize(item, depth + 1).slice(0, 4));
-        }
-        if (result.length >= 8)
-            break;
-    }
-    return result.slice(0, 8);
-}
-function surfaceRows(screen) {
-    const body = screen.body;
-    if (body.kind === 'session-picker') {
-        return [
-            row('ansi:session-picker', 'Sessions', 'heading'),
-            ...summarize(body.surface).map((text, index) => row(`ansi:session:${index}`, text, 'muted')),
-        ];
-    }
-    if (body.foreground.kind !== 'compose') {
-        const surface = body.foreground.surface;
-        return [
-            row(`ansi:foreground:${body.foreground.kind}`, body.foreground.kind, 'heading'),
-            ...summarize(surface).map((text, index) => row(`ansi:foreground:${index}`, text, 'muted')),
-        ];
-    }
-    return [];
-}
-/** ANSI mode is intentionally limited to the plain conversation surface. */
-export function supportsAnsiSurface(screen) {
-    if (screen.body.kind !== 'conversation')
-        return false;
-    return (screen.body.intro === 'none' &&
-        screen.body.foreground.kind === 'compose' &&
-        screen.body.foreground.overlays.length === 0);
-}
-export function projectAnsiSurfaceFrame(props) {
-    const body = props.screen.body;
-    const lines = [...surfaceRows(props.screen)];
-    const headers = body.kind === 'conversation' ? headerRows(props) : [];
-    if (body.kind === 'conversation') {
-        lines.push(...body.transcript.rows);
-        if (body.transcript.active.visible) {
-            if (safeText(body.transcript.active.text))
-                lines.push(...activeRows('ansi:active:text', body.transcript.active.text));
-            if (safeText(body.transcript.active.thinking))
-                lines.push(...activeRows('ansi:active:thinking', body.transcript.active.thinking, 'muted'));
-        }
-    }
-    const cursor = Math.min(Math.max(0, props.cursor ?? props.input.length), props.input.length);
-    lines.push(row('composer', `❯ ${props.input.slice(0, cursor)}▌${props.input.slice(cursor)}`, 'input'));
-    lines.push(row('status', `● ${props.status}${props.busy ? ' · busy' : ''}`, 'muted'));
-    const limit = props.rows === undefined ? lines.length : Math.max(2, props.rows);
-    const chrome = lines.slice(-2);
-    const content = [...headers, ...lines.slice(0, -2)];
-    const headerCount = Math.min(headers.length, Math.max(0, limit - 2));
-    const visibleHeaders = headers.slice(0, headerCount);
-    const bodyRows = content.slice(headers.length);
-    const contentBudget = Math.max(0, limit - headerCount - 2);
+export function projectAnsiQuietFrame(frame) {
     return {
-        columns: Math.max(1, Math.floor(props.width)),
-        rows: limit,
-        lines: [
-            ...visibleHeaders,
-            ...bodyRows.slice(-contentBudget),
-            ...chrome,
-        ].slice(-limit),
+        columns: frame.columns,
+        rows: frame.rows,
+        lines: frame.lines,
+        ...(frame.cursor === undefined ? {} : { cursor: frame.cursor }),
     };
 }
 export function TuiAnsiSurface(props) {
@@ -175,7 +55,7 @@ export function TuiAnsiSurface(props) {
         if (renderer === null)
             return;
         try {
-            renderer.draw(projectAnsiSurfaceFrame(props));
+            renderer.draw(projectAnsiQuietFrame(props.frame));
         }
         catch (error) {
             failedRef.current = true;

package/dist/cli/tui/ansi-theme.d.ts

@@ -1,3 +1,4 @@
-import type { TuiSemanticTheme, TuiTextRole } from './theme.js';
-export declare function resolveAnsiTextStyles(theme: Pick<TuiSemanticTheme, 'text' | 'noColor' | 'screenReader'>): Partial<Record<TuiTextRole, string>>;
+import type { TuiSemanticTheme } from './theme.js';
+import type { TuiTextRole as RowIrTextRole } from './tui-row-ir.js';
+export declare function resolveAnsiTextStyles(theme: Pick<TuiSemanticTheme, 'text' | 'noColor' | 'screenReader'>): Partial<Record<RowIrTextRole | 'link', string>>;
 //# sourceMappingURL=ansi-theme.d.ts.map

package/dist/cli/tui/ansi-theme.js

@@ -73,11 +73,32 @@ export function resolveAnsiTextStyles(theme) {
     if (theme.noColor || theme.screenReader)
         return {};
     const styles = {};
-    for (const [role, style] of Object.entries(theme.text)) {
+    const roleMap = {
+        body: 'body',
+        heading: 'heading',
+        muted: 'muted',
+        accent: 'focusMarker',
+        success: 'success',
+        warning: 'warning',
+        error: 'error',
+        tool: 'info',
+        selection: 'focusMarker',
+        input: 'inputMarker',
+        diffAdded: 'diffAdded',
+        diffRemoved: 'diffRemoved',
+    };
+    for (const [role, semanticRole] of Object.entries(roleMap)) {
+        const style = theme.text[semanticRole] ??
+            theme.text[role];
+        if (style === undefined)
+            continue;
         const sequence = styleSequence(style);
         if (sequence !== undefined)
             styles[role] = sequence;
     }
+    const link = theme.text.link === undefined ? undefined : styleSequence(theme.text.link);
+    if (link !== undefined)
+        styles.link = link;
     return styles;
 }
 //# sourceMappingURL=ansi-theme.js.map