@toddzheng024/dscode-bundle 0.7.12 → 0.7.13

package/vendor/tui/lib/authorization.mjs

@@ -0,0 +1,111 @@
+/** Terminal adapter over the Harness provider-authorization and credential-record seams. */
+import { spawn } from 'node:child_process';
+import { credentialKeyId, credentialKeyScope, } from '@deepseek-ai/dsh-credentials';
+/** Record scope used by the upstream pi-ai adapter for provider logins. */
+const PI_AI_RECORD_SCOPE = 'llm-pi-ai';
+/** Load only model-provider flows; unrelated future authorization domains stay out of `/model`. */
+export async function loadProviderAuthorizations(ctx) {
+    const authorization = ctx.get('authorization');
+    const credentials = ctx.get('credentials');
+    if (authorization === undefined || credentials === undefined)
+        return { rows: [], failures: [] };
+    const entries = authorization.list().filter(entry => credentialKeyScope(entry.key) === PI_AI_RECORD_SCOPE);
+    const failures = [];
+    const rows = await Promise.all(entries.map(async (entry) => {
+        let record;
+        try {
+            record = await credentials.describeRecord(entry.key);
+        }
+        catch (error) {
+            failures.push(`${entry.label}: ${error instanceof Error ? error.message : String(error)}`);
+            record = { configured: false, writable: false };
+        }
+        return {
+            key: entry.key,
+            provider: credentialKeyId(entry.key),
+            label: entry.label,
+            methods: entry.methods,
+            inFlight: entry.inFlight,
+            record,
+        };
+    }));
+    return { rows, failures };
+}
+/** Subscribe to login settlement and credential-record changes. */
+export function subscribeProviderAuthorizations(ctx, listener) {
+    const settled = ctx.on('authorization/settled', (key) => {
+        if (credentialKeyScope(key) === PI_AI_RECORD_SCOPE)
+            listener();
+    });
+    const records = ctx.on('credentials/record-updated', (key) => {
+        if (credentialKeyScope(key) === PI_AI_RECORD_SCOPE)
+            listener();
+    });
+    return () => {
+        settled();
+        records();
+    };
+}
+/** Begin one provider login through the interaction surface owned by the caller. */
+export async function beginProviderAuthorization(ctx, row, method, interaction, signal) {
+    const authorization = ctx.get('authorization');
+    if (authorization === undefined)
+        throw new Error('provider login is unavailable in this profile');
+    return (await authorization.begin({ key: row.key, method, interaction, signal })).status;
+}
+/** Cancel the attempt currently serving this provider, if any. */
+export function cancelProviderAuthorization(ctx, key) {
+    ctx.get('authorization')?.cancel(key);
+}
+/** Remove an authorization record without changing the provider's settings profile. */
+export async function logoutProviderAuthorization(ctx, row) {
+    const credentials = ctx.get('credentials');
+    if (credentials === undefined)
+        throw new Error('credential storage is unavailable in this profile');
+    const current = await credentials.describeRecord(row.key);
+    if (!current.configured)
+        return;
+    if (!current.writable)
+        throw new Error('this login record is read-only');
+    await credentials.deleteRecord(row.key);
+}
+/** Open an authorization URL with the platform default browser, without invoking a shell. */
+export function openAuthorizationUrl(raw) {
+    let url;
+    try {
+        url = new URL(raw);
+    }
+    catch {
+        return false;
+    }
+    if (url.protocol !== 'https:' && url.protocol !== 'http:')
+        return false;
+    const target = url.toString();
+    try {
+        const child = process.platform === 'win32'
+            ? spawn('explorer.exe', [target], { detached: true, stdio: 'ignore' })
+            : process.platform === 'darwin'
+                ? spawn('/usr/bin/open', [target], { detached: true, stdio: 'ignore' })
+                : spawn('xdg-open', [target], { detached: true, stdio: 'ignore' });
+        child.once('error', () => { });
+        child.unref();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Compact value-free status for the provider list. */
+export function providerAuthorizationStatus(row) {
+    if (row === undefined)
+        return 'login unavailable';
+    if (row.inFlight)
+        return 'login in progress';
+    if (!row.record.configured)
+        return 'not logged in';
+    return row.record.kind === 'grant' ? 'OAuth' : 'interactive API key';
+}
+/** Find a provider's login flow from a previously loaded directory. */
+export function authorizationForProvider(directory, provider) {
+    return directory?.rows.find(row => row.provider === provider);
+}

package/vendor/tui/lib/commands.mjs

@@ -0,0 +1,123 @@
+/**
+ * Slash-command bridge: forwards terminal command lines into the shared
+ * `ctx.commands` registry (the same surface the web composer dispatches
+ * through) and exposes the live descriptor list as completion candidates.
+ * The runner keeps only its own TUI-local commands (`/help`, `/quit`,
+ * `/clear`, `/model`) ahead of the registry dispatch.
+ *
+ * @module @deepseek-ai/dsh-tui/commands
+ */
+/**
+ * Watch the live command registry. Reads the current list immediately and
+ * re-reads on every registry mutation or agent retarget; notification
+ * failures are contained by the registry itself, so this watcher only ever
+ * re-reads. Without a `commands` service the view stays empty and all lines
+ * fall through to normal prompts.
+ * @param ctx - context carrying the `commands` service (optional).
+ * @returns the view the completion menu subscribes to.
+ */
+export function watchCommands(ctx) {
+    const commands = ctx.get('commands');
+    let agent;
+    let descriptors = [];
+    let error;
+    // The agent whose scoped view the current descriptors were read for: a
+    // failure before this agent ever loaded clears the list instead of keeping
+    // another session's commands completable here.
+    let loadedFor;
+    const listeners = new Set();
+    // Content gate: the host registry allocates a fresh array on every list()
+    // call and 0.1.5 emits commands/change for every scoped register AND
+    // dispose (a startup registration wave lands inside React's commit
+    // windows). A fresh identity per event chains nested passive updates past
+    // React's 50-deep limit ("Maximum update depth exceeded"), so an unchanged
+    // catalog keeps the previous array identity and notifies nobody — the same
+    // discipline the skills gate and the store's frame throttle established.
+    const descriptorFingerprint = (list) => JSON.stringify(list.map(descriptor => [descriptor.name, descriptor.description, descriptor.input?.hint ?? '', descriptor.input?.attachments === true]));
+    let lastFingerprint = '[]';
+    let lastNotifiedError;
+    const changed = (next, nextError) => descriptorFingerprint(next) !== lastFingerprint || nextError !== lastNotifiedError;
+    // Frame throttle: coalesce a same-tick event storm into one notification
+    // (the transcript store's NOTIFY_FRAME_MS contract).
+    let notifyScheduled = false;
+    const notify = () => {
+        if (notifyScheduled)
+            return;
+        notifyScheduled = true;
+        setImmediate(() => {
+            notifyScheduled = false;
+            for (const listener of listeners)
+                listener();
+        });
+    };
+    const refresh = () => {
+        if (commands === undefined || agent === undefined)
+            return;
+        let next;
+        let nextError;
+        try {
+            next = commands.list(agent);
+            loadedFor = agent;
+        }
+        catch (cause) {
+            // Keep the last good catalog for the SAME agent, but change its identity
+            // so subscribers can render the recoverable failure in /help; an agent
+            // that never loaded starts from empty.
+            next = loadedFor === agent ? [...descriptors] : [];
+            nextError = cause instanceof Error ? cause.message : String(cause);
+        }
+        if (!changed(next, nextError))
+            return;
+        descriptors = next;
+        error = nextError;
+        lastFingerprint = descriptorFingerprint(next);
+        lastNotifiedError = nextError;
+        notify();
+    };
+    if (commands !== undefined) {
+        ctx.on('commands/change', () => refresh());
+    }
+    return {
+        get descriptors() {
+            return descriptors;
+        },
+        get error() {
+            return error;
+        },
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+        setAgent(next) {
+            agent = next;
+            refresh();
+        },
+    };
+}
+/**
+ * Whether one command line is a syntactically valid slash command.
+ * @param line - the complete candidate line.
+ * @returns true when the line parses as `/name` or `/name input`.
+ */
+export function isSlashLine(line) {
+    return /^\/[a-z][a-z0-9_-]*(?=$|[\t ])/u.test(line);
+}
+/**
+ * The submission payload for one composer line. Trim is a blank check, not a
+ * rewrite: an ordinary prompt keeps its exact leading indentation, inner
+ * layout, and trailing spaces (pasted code must reach the model verbatim).
+ * Only trailing line terminators are stripped — a draft's final newline is a
+ * paste/Enter artifact (an open bracketed paste turns Enter into an inserted
+ * newline), never deliberate content. A syntactic slash line still normalizes
+ * fully so command routing stays stable (completion inserts a trailing space
+ * after `/name`).
+ * @param line - the complete draft text.
+ * @returns the text to submit verbatim.
+ */
+export function submissionPayload(line) {
+    const withoutTrailingNewlines = line.replace(/[\r\n]+$/u, '');
+    const trimmed = withoutTrailingNewlines.trim();
+    return isSlashLine(trimmed) ? trimmed : withoutTrailingNewlines;
+}

package/vendor/tui/lib/dscode/chat.mjs

@@ -0,0 +1,64 @@
+/**
+ * dscode: DSCODE's transcript rendering. The default view stays quiet — tool
+ * calls and the model's thinking only appear (dim) once verbose is on — and a
+ * wrapped user prompt is painted as one continuous background band.
+ *
+ * @module dsh-code/dscode/chat
+ */
+import { visibleColumns } from '../render/markdown.mjs';
+import { hangingStyledLines, hangingTextLines, lineSegment, textLines, transcriptEntryLines, } from '../render/lines.mjs';
+/** Pad every physical row of a wrapped prompt so its background stays unbroken. */
+export function userBackgroundRows(rows, columns, measure) {
+    const width = Math.max(1, Math.floor(columns));
+    return rows.map(row => {
+        const used = row.segments.reduce((sum, segment) => sum + measure(segment.text), 0);
+        return {
+            ...row,
+            background: 'user',
+            segments: [...row.segments, { text: ' '.repeat(Math.max(0, width - used)), style: 'plain' }],
+        };
+    });
+}
+/** The folded thinking tail: one dim paragraph, capped, with the Ctrl+O hint. */
+function thinkingLines(reasoning, width) {
+    const lines = hangingTextLines('Thinking: ' + reasoning.replace(/\s+/g, ' ').trim(), width, '· ', 'dimItalic', '  ');
+    const cap = 8;
+    return lines.length <= cap
+        ? lines
+        : [...lines.slice(0, cap), ...textLines('  … ' + (lines.length - cap) + ' more lines · Ctrl+O opens the full history', width, 'dim')];
+}
+/**
+ * Render one transcript entry the DSCODE way: tool rows are quiet unless verbose
+ * is on, assistant rows fold their thinking above the answer, and user prompts
+ * carry the background band.
+ */
+export function dscodeChatLines(entry, columns, verbose = false) {
+    const width = Math.max(1, Math.floor(columns));
+    if (entry.kind === 'tool') {
+        if (!verbose)
+            return [];
+        const state = entry.state === 'running' ? ' · running' : entry.state === 'error' ? ' · error' : '';
+        const lines = hangingStyledLines([
+            lineSegment('Tool Call: ' + entry.name, 'dim'),
+            lineSegment(entry.preview ? ' ' + entry.preview : '', 'dim'),
+            lineSegment(state, entry.state === 'error' ? 'error' : 'dim'),
+        ], width, '· ', 'dim', '  ', 'dim');
+        if (entry.summary) {
+            lines.push(...hangingTextLines('Output: ' + entry.summary, width, '  ', entry.state === 'error' ? 'error' : 'dim', '    '));
+        }
+        lines.push({ segments: [] });
+        return lines;
+    }
+    if (entry.kind === 'assistant') {
+        const thinking = verbose && entry.reasoning ? [...thinkingLines(entry.reasoning, width), { segments: [] }] : [];
+        if (!entry.text && !entry.interrupted)
+            return thinking;
+        const body = [...thinking, ...transcriptEntryLines({ ...entry, reasoning: '' }, columns, false, false, false)];
+        // The turn's last reply closes the turn with its own rule and breathing rows.
+        return entry.turnEnded === true
+            ? [...body, { segments: [] }, { segments: [{ text: '─'.repeat(width), style: 'dim' }] }, { segments: [] }]
+            : body;
+    }
+    const rows = transcriptEntryLines(entry, columns, false, false, false);
+    return entry.kind === 'user' && !entry.notice ? [...userBackgroundRows(rows, columns, visibleColumns), { segments: [] }] : rows;
+}

package/vendor/tui/lib/dscode/flags.mjs

@@ -0,0 +1,32 @@
+/**
+ * dscode: small UI preferences that must survive a restart (the verbose
+ * transcript toggle). They live beside the launcher's other state, one JSON file
+ * per flag, and a read or write that fails never breaks the render path.
+ *
+ * @module dsh-code/dscode/flags
+ */
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+/** The directory DSCODE keeps its own terminal state in. */
+function stateDirectory() {
+    return join(homedir(), '.dsh', 'dsh-code');
+}
+/** One persisted boolean; a missing or corrupt file falls back. */
+export function loadFlag(name, fallback = false) {
+    try {
+        const value = JSON.parse(readFileSync(join(stateDirectory(), name + '.json'), 'utf8'))[name];
+        return typeof value === 'boolean' ? value : fallback;
+    }
+    catch {
+        return fallback;
+    }
+}
+/** Persist one boolean; a failed write is ignored so the UI never blocks. */
+export function saveFlag(name, value) {
+    try {
+        mkdirSync(stateDirectory(), { recursive: true });
+        writeFileSync(join(stateDirectory(), name + '.json'), JSON.stringify({ [name]: value }, null, 2) + '\n');
+    }
+    catch { }
+}

package/vendor/tui/lib/dscode/model-search.mjs

@@ -0,0 +1,68 @@
+/**
+ * dscode: the /model picker's row filter. Only the session's current provider is
+ * listed, and typing narrows at once instead of acting as a shortcut: BM25 over the
+ * model name (weight 3), the id (2) and the provider (1). Letters and digits split
+ * into separate tokens, so `glm5` finds GLM 5.3, and the word still being typed
+ * matches the tokens it starts (`kim` finds Kimi). Rows matching every word win
+ * over rows matching some, and whatever matches is presented in alphabetical order of
+ * the displayed label with digits compared naturally.
+ *
+ * @module dsh-code/dscode/model-search
+ */
+export function dscodeFilterModels(rows, query, provider) {
+    // One provider at a time: the picker lists the routes the session can actually select.
+    const directory = provider === void 0 ? rows : rows.filter(row => row.provider === provider);
+    const label = row => String(row.modelName ?? row.model ?? "");
+    // Display order is the label itself, so the list reads alphabetically and digits inside a
+    // name compare naturally ("GLM 5.2" before "GLM 5.3"); searching narrows rows, never re-ranks them.
+    const byLabel = (left, right) => label(left).localeCompare(label(right), void 0, {
+        numeric: true,
+        sensitivity: "base"
+    }) || String(left.model ?? "").localeCompare(String(right.model ?? "")) || String(left.provider ?? "").localeCompare(String(right.provider ?? ""));
+    const tokenize = text => String(text ?? '').normalize('NFKC').toLowerCase().match(/[a-z]+|[0-9]+|[^\s\x00-\x7f]+/g) ?? [];
+    const raw = String(query ?? '');
+    const words = tokenize(raw);
+    if (words.length === 0)
+        return [...directory].sort(byLabel);
+    const typing = /\s$/.test(raw) ? -1 : words.length - 1;
+    const fields = [['modelName', 3], ['model', 2], ['providerName', 1], ['provider', 1]];
+    const docs = directory.map(row => {
+        const counts = new Map();
+        let length = 0;
+        for (const [field, weight] of fields)
+            for (const token of tokenize(row[field])) {
+                counts.set(token, (counts.get(token) ?? 0) + weight);
+                length += weight;
+            }
+        return { row, counts, length };
+    });
+    const average = docs.reduce((sum, doc) => sum + doc.length, 0) / Math.max(1, docs.length);
+    const frequency = (doc, word, prefix) => {
+        if (!prefix)
+            return doc.counts.get(word) ?? 0;
+        let sum = 0;
+        for (const [token, count] of doc.counts)
+            if (token.startsWith(word))
+                sum += token === word ? count : count * 0.8;
+        return sum;
+    };
+    const k1 = 1.2, b = 0.75;
+    const terms = words.map((word, index) => {
+        const matches = docs.map(doc => frequency(doc, word, index === typing));
+        const found = matches.filter(value => value > 0).length;
+        return { matches, idf: Math.log(1 + (docs.length - found + 0.5) / (found + 0.5)) };
+    });
+    const scored = docs.map((doc, index) => {
+        let score = 0, hits = 0;
+        for (const term of terms) {
+            const tf = term.matches[index];
+            if (tf <= 0)
+                continue;
+            hits += 1;
+            score += term.idf * tf * (k1 + 1) / (tf + k1 * (1 - b + b * doc.length / average));
+        }
+        return { row: doc.row, score, hits };
+    }).filter(entry => entry.hits > 0);
+    const complete = scored.filter(entry => entry.hits === terms.length);
+    return (complete.length > 0 ? complete : scored).map(entry => entry.row).sort(byLabel);
+}

package/vendor/tui/lib/dscode/paste.mjs

@@ -0,0 +1,87 @@
+/**
+ * dscode: large pastes collapse to one marker in the draft so the composer stays
+ * readable, then expand back to the full text on submit. The marker is atomic for
+ * every edit and cursor move, so a paste can never be half-deleted.
+ *
+ * @module dsh-code/dscode/paste
+ */
+/** Pastes longer than this collapse to a marker. */
+export const LARGE_PASTE_CHARS = 200;
+export function collapseLargePaste(text, draft, pastes) {
+    const safe = text.replaceAll('\r\n', '\n').replaceAll('\r', '\n').replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/gu, '').replaceAll('\t', '  ');
+    const count = [...safe].length;
+    if (count <= LARGE_PASTE_CHARS)
+        return safe;
+    // Keep an executable-looking first line visible to the command router.
+    if (draft.trim() === '' && /^\s*[!/]/u.test(safe))
+        return safe;
+    const base = `[Pasted Content ${count} chars]`;
+    let marker = base;
+    for (let suffix = 2; draft.includes(marker) || pastes.has(marker); suffix++)
+        marker = `${base} #${suffix}`;
+    pastes.set(marker, safe);
+    return marker;
+}
+export function expandLargePastes(value, pastes) {
+    const markers = [...pastes.keys()].sort((left, right) => right.length - left.length);
+    let expanded = '';
+    let offset = 0;
+    while (offset < value.length) {
+        let found = -1;
+        let match;
+        for (const marker of markers) {
+            const at = value.indexOf(marker, offset);
+            if (at >= 0 && (found < 0 || at < found)) {
+                found = at;
+                match = marker;
+            }
+        }
+        if (match === undefined)
+            break;
+        expanded += value.slice(offset, found) + pastes.get(match);
+        offset = found + match.length;
+    }
+    return expanded + value.slice(offset);
+}
+export function pasteAtomicEdit(before, edit, pastes) {
+    let prefix = 0;
+    while (prefix < before.length && prefix < edit.value.length && before[prefix] === edit.value[prefix])
+        prefix++;
+    let suffix = 0;
+    while (suffix < before.length - prefix && suffix < edit.value.length - prefix && before[before.length - suffix - 1] === edit.value[edit.value.length - suffix - 1])
+        suffix++;
+    let from = prefix, to = before.length - suffix;
+    const inserted = edit.value.slice(prefix, edit.value.length - suffix);
+    let touched = false;
+    const originalPastes = new Map(pastes);
+    for (const marker of pastes.keys()) {
+        const start = before.indexOf(marker);
+        if (start < 0)
+            continue;
+        const end = start + marker.length;
+        if (from < end && to > start || from === to && from > start && from < end) {
+            from = Math.min(from, start);
+            to = Math.max(to, end);
+            pastes.delete(marker);
+            touched = true;
+        }
+    }
+    if (touched)
+        edit = { ...edit, value: before.slice(0, from) + inserted + before.slice(to), cursor: from + inserted.length,
+            killed: edit.killed === undefined ? undefined : expandLargePastes(before.slice(from, to), originalPastes) };
+    for (const marker of pastes.keys())
+        if (!edit.value.includes(marker) && before.includes(marker))
+            pastes.delete(marker);
+    return edit;
+}
+export function pasteCursorEdge(value, previous, next, pastes) {
+    for (const marker of pastes.keys()) {
+        const start = value.indexOf(marker);
+        if (start < 0)
+            continue;
+        const end = start + marker.length;
+        if (next > start && next < end)
+            return next < previous ? start : end;
+    }
+    return next;
+}

package/vendor/tui/lib/dscode/telemetry.mjs

@@ -0,0 +1,82 @@
+/**
+ * dscode: the footer telemetry tints its live numbers — the request rate by tier
+ * and the cache-hit rate by how well the prompt prefix is being reused.
+ *
+ * @module dsh-code/dscode/telemetry
+ */
+import { createElement } from 'react';
+import { Text } from 'ink';
+import { getPalette, getTheme, inkColor } from '../theme.mjs';
+/** Request-rate tiers: yellow under 75 tps, green to 150, blue to 250, purple above. */
+export function dscodeTpsTone(rate) {
+    if (!Number.isFinite(rate) || rate < 0)
+        return null;
+    if (rate < 75)
+        return 'yellow';
+    if (rate < 150)
+        return 'green';
+    if (rate <= 250)
+        return 'blue';
+    return 'purple';
+}
+/** Cache-hit tiers: red under 90%, yellow to 95, green to 98, blue above. */
+export function dscodeCacheTone(rate) {
+    if (!Number.isFinite(rate) || rate < 0)
+        return null;
+    if (rate < 90)
+        return 'red';
+    if (rate < 95)
+        return 'yellow';
+    if (rate < 98)
+        return 'green';
+    return 'blue';
+}
+/** Every label the cache figure can carry, across the shipped interface languages. */
+const DSCode_CACHE_LABELS = ['cache hit', '缓存命中', '快取命中', 'キャッシュヒット', '캐시 적중', 'éxitos de caché'];
+/** The ink colour for a tier, theme-aware for the two ends of the scale. */
+export function dscodeTpsInkColor(tone) {
+    const palette = getPalette();
+    if (tone === 'red')
+        return inkColor(getTheme() === 'light' ? [185, 28, 28] : [248, 113, 113]);
+    if (tone === 'yellow')
+        return inkColor(palette.warn);
+    if (tone === 'green')
+        return inkColor(palette.success);
+    if (tone === 'blue')
+        return inkColor(palette.brandBright);
+    if (tone === 'purple')
+        return inkColor(getTheme() === 'light' ? [126, 34, 206] : [192, 132, 252]);
+    return undefined;
+}
+/**
+ * Split a telemetry string into tintable runs. The `tps` figures and the trailing
+ * cache-hit rate carry a tier; everything else keeps the surrounding colour.
+ */
+export function dscodeTelemetryParts(value) {
+    const result = [];
+    const parts = String(value).split(' | ');
+    for (const [index, part] of parts.entries()) {
+        if (index > 0)
+            result.push({ text: ' | ', tone: null });
+        const match = /^(.+?: )(~?(?:\d+(?:\.\d+)?|--)) tps$/.exec(part);
+        if (match) {
+            const display = match[2];
+            const rate = Number(display.startsWith('~') ? display.slice(1) : display);
+            result.push({ text: match[1], tone: null }, { text: display + ' tps', tone: display ? dscodeTpsTone(rate) : null });
+            continue;
+        }
+        // Only a recognised cache label at the very end of the line is tinted.
+        const labelled = index === parts.length - 1 ? /^(.*?)(\d+(?:\.\d+)?)%$/.exec(part) : null;
+        const cache = labelled && DSCode_CACHE_LABELS.includes(labelled[1].replace(/:\s*$/, '').trim().toLowerCase()) ? labelled : null;
+        if (cache) {
+            result.push({ text: cache[1], tone: null }, { text: cache[2] + '%', tone: dscodeCacheTone(Number(cache[2])) });
+            continue;
+        }
+        result.push({ text: part, tone: null });
+    }
+    return result;
+}
+/** The telemetry run as Ink text nodes, one per tinted segment. */
+export function dscodeTelemetryNodes(value, key) {
+    return dscodeTelemetryParts(value).map((part, index) => createElement(Text, { key: key + 'p' + index, color: dscodeTpsInkColor(part.tone) }, part.text));
+}

package/vendor/tui/lib/dscode/welcome.mjs

@@ -0,0 +1,100 @@
+/**
+ * dscode: the welcome screen's pixel snowflake, its half-block row packing and
+ * the path folding that keeps a long directory inside the details column.
+ *
+ * @module dsh-code/dscode/welcome
+ */
+import { singleLineText, truncateColumns } from '../render/text.mjs';
+import { visibleColumns } from '../render/markdown.mjs';
+export function welcomePath(path, width) {
+    const full = singleLineText(path || '');
+    if (visibleColumns(full) <= width)
+        return full;
+    const segments = full.split(/[\\/]/).filter(Boolean);
+    let suffix = '';
+    for (let index = segments.length - 1; index >= 0; index--) {
+        const candidate = '/' + segments[index] + suffix;
+        if (visibleColumns('…' + candidate) > width)
+            break;
+        suffix = candidate;
+    }
+    return suffix ? '…' + suffix : '…' + truncateColumns(segments.at(-1) || full, Math.max(1, width - 1));
+}
+/** Pixel rows of the welcome snowflake for terminals of 24+ rows. */
+export const WELCOME_ART = [
+    "...........1.1..........",
+    "............1...........",
+    "............1...........",
+    ".........1..1..1........",
+    ".......1..22222..1......",
+    "...1...1....2....1...1..",
+    "..11...2....2....2...11.",
+    "....11.2...222...2.11...",
+    "......22.22.3.22.22.....",
+    ".....22.22.333.22.22....",
+    "....1...2.33332.2...1...",
+    "........2.33322.2.......",
+    "....1...2.33222.2...1...",
+    ".....22.22.222.22.22....",
+    "......22.22.3.22.22.....",
+    "....11.2...222...2.11...",
+    "..11...2....2....2...11.",
+    "...1...1....2....1...1..",
+    ".......1..22222..1......",
+    ".........1..1..1........",
+    "............1...........",
+    "............1...........",
+    "...........1.1..........",
+    "........................"
+];
+/** The shorter snowflake used under 26 rows. */
+export const WELCOME_ART_SMALL = [
+    "..........1.1.........",
+    "...........1..........",
+    "........1..1..1.......",
+    ".........1.2.1........",
+    "...1..1...222...1..1..",
+    "...1..1....2....1..1..",
+    "..1.1.2...222...2.1.1.",
+    ".....22.22.3.22.22....",
+    "....12.22.333.22.21...",
+    "...1...2.33332.2...1..",
+    ".......2.33322.2......",
+    "...1...2.33222.2...1..",
+    "....12.22.222.22.21...",
+    ".....22.22.3.22.22....",
+    "..1.1.2...222...2.1.1.",
+    "...1..1....2....1..1..",
+    "...1..1...222...1..1..",
+    ".........1.2.1........",
+    "........1..1..1.......",
+    "...........1..........",
+    "..........1.1.........",
+    "......................"
+];
+export function welcomeArtRows(grid, tones) {
+    const rows = [];
+    for (let y = 0; y < grid.length; y += 2) {
+        const top = grid[y] || '';
+        const bottom = grid[y + 1] || '';
+        const segments = [];
+        for (let x = 0; x < Math.max(top.length, bottom.length); x++) {
+            const upper = tones[top[x]] || '';
+            const lower = tones[bottom[x]] || '';
+            const glyph = upper && lower ? upper === lower ? '\u2588' : '\u2580' : upper ? '\u2580' : lower ? '\u2584' : ' ';
+            const color = upper || lower;
+            const background = upper && lower && upper !== lower ? lower : '';
+            const last = segments[segments.length - 1];
+            if (last && last.glyph === glyph && last.color === color && last.background === background)
+                last.text += glyph;
+            else
+                segments.push({ glyph, text: glyph, color, background });
+        }
+        rows.push(segments);
+    }
+    return rows;
+}
+/** dscode: pad a label to a column width (CJK-safe). */
+export function dscodePadEnd(text, width) {
+    return text + ' '.repeat(Math.max(1, width - visibleColumns(text)));
+}