/**

* Glyph selection for CLI output.

*

* On Windows, console output is interpreted via the active output

* codepage. PowerShell 5.1 and cmd.exe in legacy conhost default to

* OEM codepages (CP437, CP936, ...), so UTF-8 bytes written to the

* console render as mojibake (see #168). The shimmer worker is hit

* hardest because it uses `fs.writeSync(1, ...)` (raw bytes, no

* TTY-aware encoding conversion) to keep animation smooth while the

* main thread is blocked in SQLite. To stay readable everywhere, we

* fall back to ASCII glyphs whenever the terminal is not known to

* handle UTF-8.

*

* The Windows branch must agree with @clack/prompts (which bundles

* `is-unicode-supported`): clack draws the outer `┌ │ └` frame around

* init/index/sync output, and if it decides Unicode while we decide

* ASCII, one block mixes `│` and `|` rails (#398). The terminals the

* list recognizes (Windows Terminal, VS Code, ConEmu/Cmder, Alacritty,

* JetBrains, Terminus, CI log viewers) all run with a UTF-8-capable

* output path, so the raw-byte shimmer writes render correctly there

* too; unrecognized Windows consoles keep the safe ASCII fallback —

* and clack falls back to ASCII in those as well, so output stays

* consistent in both directions.

*

* Detection:

* - `CODEGRAPH_ASCII=1` -> ASCII (escape hatch for any terminal)

* - `CODEGRAPH_UNICODE=1` -> Unicode (opt-in on any terminal)

* - Windows -> mirror is-unicode-supported (see above)

* - Linux kernel console (`TERM=linux`) -> ASCII

* - Everything else -> Unicode

*/

export function supportsUnicode(): boolean {

if (process.env.CODEGRAPH_ASCII === '1') return false;

if (process.env.CODEGRAPH_UNICODE === '1') return true;

if (process.platform === 'win32') {

const env = process.env;

return Boolean(

env.CI ||

env.WT_SESSION || // Windows Terminal

env.TERMINUS_SUBLIME ||

env.ConEmuTask === '{cmd::Cmder}' || // ConEmu and cmder

env.TERM_PROGRAM === 'Terminus-Sublime' ||

env.TERM_PROGRAM === 'vscode' ||

env.TERM === 'xterm-256color' ||

env.TERM === 'alacritty' ||

env.TERMINAL_EMULATOR === 'JetBrains-JediTerm'

);

}

return process.env.TERM !== 'linux';

}

export interface Glyphs {

ok: string;

err: string;

info: string;

warn: string;

spinner: string[];

barFilled: string;

barEmpty: string;

rail: string;

phaseDone: string;

dash: string;

hLine: string;

treeBranch: string;

treeLast: string;

treePipe: string;

}

export const UNICODE_GLYPHS: Glyphs = {

ok: '✓',

err: '✗',

info: 'ℹ',

warn: '⚠',

spinner: ['·', '✢', '✳', '✶', '✻', '✽'],

barFilled: '█',

barEmpty: '░',

rail: '│',

phaseDone: '◆',

dash: '—',

hLine: '─',

treeBranch: '├── ',

treeLast: '└── ',

treePipe: '│ ',

};

export const ASCII_GLYPHS: Glyphs = {

ok: '[OK]',

err: '[ERR]',

info: '[i]',

warn: '[!]',

spinner: ['.', '*', '+', 'x', 'o', 'O'],

barFilled: '#',

barEmpty: '-',

rail: '|',

phaseDone: '*',

dash: '-',

hLine: '-',

treeBranch: '|-- ',

treeLast: '`-- ',

treePipe: '| ',

};

let cached: Glyphs | null = null;

export function getGlyphs(): Glyphs {

if (cached === null) {

cached = supportsUnicode() ? UNICODE_GLYPHS : ASCII_GLYPHS;

}

return cached;

}

/**

* Unicode support for the RAW console write path — `fs.writeSync(1, ...)`,

* used only by the shimmer worker's transient animation frames. Raw bytes

* bypass Node's TTY-aware conversion and get decoded by the ACTIVE CONSOLE

* CODEPAGE on Windows; OEM codepages (CP437, CP936, ...) mojibake UTF-8

* there even inside Windows Terminal, whose ConPTY still decodes app output

* with the session codepage (#168). So the raw path stays ASCII on every

* Windows terminal unless the user opts in via CODEGRAPH_UNICODE=1 —

* independent of `supportsUnicode()`, which governs the codepage-immune

* main-thread writes (`process.stdout` uses the wide-char console API).

*/

export function supportsUnicodeRawWrites(): boolean {

if (process.env.CODEGRAPH_ASCII === '1') return false;

if (process.env.CODEGRAPH_UNICODE === '1') return true;

if (process.platform === 'win32') return false;

return process.env.TERM !== 'linux';

}

export function getRawWriteGlyphs(): Glyphs {

return supportsUnicodeRawWrites() ? UNICODE_GLYPHS : ASCII_GLYPHS;

}

/** Reset the cached glyph set. Test-only; production code should call `getGlyphs()`. */

export function _resetGlyphsCache(): void {

cached = null;

}