@askdkc/dsh-cli 0.11.3

package/lib/types/utils/imageResize.js

@@ -0,0 +1,272 @@
+/**
+ * Inbound image adaptation for the composer's staging gate.
+ *
+ * The upstream attachment store admits images by media type, byte budget,
+ * pixel budget and a per-side dimension cap (`maxImageDimension`). Two kinds
+ * of paste used to fail with no user-side recourse: one that exceeds the
+ * dimension cap, and one whose format the deployment does not accept. This
+ * module measures the bytes BEFORE staging and produces an admissible pair
+ * (bytes + media type) through sharp — an optionalDependency, absent on
+ * minimal installs, which must degrade with a clear error, not a crash.
+ *
+ * Sizing probe is pure byte inspection (PNG/JPEG/WebP/GIF). Formats the
+ * probe cannot identify return null and MUST be forced through an actual
+ * decode for measurement — the #432 review gap was letting an
+ * "unrecognized but under the byte cap" image through, where a
+ * large-resolution small-byte WebP/GIF would sail past the probe and be
+ * rejected by upstream afterwards.
+ *
+ * The single entry point is {@link adaptImageForAdmission}: it decides
+ * whether anything has to change (resample, re-encode, or both) and reports
+ * exactly what it did, so the caller can tell the user instead of silently
+ * rewriting their image.
+ */
+const PNG_SIGNATURE = [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a];
+function probePng(b) {
+    // IHDR is required to be the first chunk: width/height are big-endian
+    // u32 at fixed offsets 16/20.
+    if (b.length < 24)
+        return null;
+    const width = (b[16] << 24) | (b[17] << 16) | (b[18] << 8) | b[19];
+    const height = (b[20] << 24) | (b[21] << 16) | (b[22] << 8) | b[23];
+    return width > 0 && height > 0 ? { width, height } : null;
+}
+function probeJpeg(b) {
+    // Walk the segment chain to the first SOF marker (C0–CF except C4 DHT,
+    // C8 JPG, CC DAC); height/width are big-endian u16 at +5/+7 inside it.
+    if (b.length < 4 || b[0] !== 0xff || b[1] !== 0xd8)
+        return null;
+    let i = 2;
+    while (i + 9 < b.length) {
+        if (b[i] !== 0xff)
+            return null;
+        const marker = b[i + 1];
+        if (marker === 0xd8 || (marker >= 0xd0 && marker <= 0xd9)) {
+            i += 2; // standalone markers carry no length
+            continue;
+        }
+        const segLen = (b[i + 2] << 8) | b[i + 3];
+        if (segLen < 2)
+            return null;
+        const isSof = marker >= 0xc0 && marker <= 0xcf
+            && marker !== 0xc4 && marker !== 0xc8 && marker !== 0xcc;
+        if (isSof) {
+            const height = (b[i + 5] << 8) | b[i + 6];
+            const width = (b[i + 7] << 8) | b[i + 8];
+            return width > 0 && height > 0 ? { width, height } : null;
+        }
+        i += 2 + segLen;
+    }
+    return null;
+}
+function probeWebp(b) {
+    // RIFF....WEBP followed by VP8X (extended) or VP8 (lossy) or VP8L
+    // (lossless). VP8X carries the canvas size as 1-subtracted 24-bit LE;
+    // VP8 carries u16 LE after the frame tag; VP8L packs 14-bit
+    // 1-subtracted fields after the signature byte.
+    if (b.length < 30)
+        return null;
+    if (b[0] !== 0x52 || b[1] !== 0x49 || b[2] !== 0x46 || b[3] !== 0x46)
+        return null;
+    if (b[8] !== 0x57 || b[9] !== 0x45 || b[10] !== 0x42 || b[11] !== 0x50)
+        return null;
+    const fourcc = String.fromCharCode(b[12], b[13], b[14], b[15]);
+    if (fourcc === 'VP8X') {
+        const width = 1 + ((b[24] | (b[25] << 8) | (b[26] << 16)) & 0xffffff);
+        const height = 1 + ((b[27] | (b[28] << 8) | (b[29] << 16)) & 0xffffff);
+        return { width, height };
+    }
+    if (fourcc === 'VP8 ') {
+        // Uncompressed chunk header (10 bytes) then keyframe tag (3) then the
+        // dimensions: 14-bit width/height in the low bits of each u16, with a
+        // 2-bit horizontal/vertical scale in the top bits (RFC 6386 §9.1). Mask
+        // them off, or an encoder that sets the scale bits is measured up to
+        // 49152px too wide and gets shrunk far past the caps.
+        const width = (b[26] | (b[27] << 8)) & 0x3fff;
+        const height = (b[28] | (b[29] << 8)) & 0x3fff;
+        return width > 0 && height > 0 ? { width, height } : null;
+    }
+    if (fourcc === 'VP8L') {
+        const bits = (b[21] | (b[22] << 8) | (b[23] << 16) | (b[24] << 24)) >>> 0;
+        const width = (bits & 0x3fff) + 1;
+        const height = ((bits >> 14) & 0x3fff) + 1;
+        return { width, height };
+    }
+    return null;
+}
+function probeGif(b) {
+    // Logical screen descriptor: u16 LE at fixed offsets 6/8. A truncated header
+    // reads as 0×0 and would then look "inside the caps", so the zero check is
+    // what keeps an unmeasurable file on the decode path.
+    const width = b[6] | (b[7] << 8);
+    const height = b[8] | (b[9] << 8);
+    return width > 0 && height > 0 ? { width, height } : null;
+}
+/**
+ * Measure intrinsic pixel dimensions from the encoded bytes alone — no
+ * decode, no dependencies. Recognizes PNG / JPEG / WebP (VP8X, VP8,
+ * VP8L) / GIF; anything else returns null, which callers MUST treat as
+ * "unknown, force a real decode" — never as "small enough".
+ */
+export function probeImageSize(bytes) {
+    if (bytes.length >= 8 && PNG_SIGNATURE.every((v, i) => bytes[i] === v)) {
+        return probePng(bytes);
+    }
+    if (bytes.length >= 2 && bytes[0] === 0xff && bytes[1] === 0xd8) {
+        return probeJpeg(bytes);
+    }
+    if (bytes.length >= 30 && bytes[0] === 0x52 && bytes[8] === 0x57) {
+        return probeWebp(bytes);
+    }
+    if (bytes.length >= 10
+        && bytes[0] === 0x47 && bytes[1] === 0x49 && bytes[2] === 0x46 && bytes[3] === 0x38) {
+        return probeGif(bytes);
+    }
+    return null;
+}
+/** Whether a measured image already satisfies the dimension/pixel caps. */
+export function withinDimensionLimits(size, limits) {
+    return size.width <= limits.maxImageDimension
+        && size.height <= limits.maxImageDimension
+        && size.width * size.height <= limits.maxImagePixels;
+}
+/**
+ * Target dimensions that bring an oversized image inside `limits` while
+ * preserving the aspect ratio: scale down by the largest of the three
+ * required factors (per-side, per-side, total-pixels).
+ */
+export function downscaleTarget(size, limits) {
+    const factors = [
+        size.width / limits.maxImageDimension,
+        size.height / limits.maxImageDimension,
+        Math.sqrt((size.width * size.height) / limits.maxImagePixels),
+    ];
+    const factor = Math.max(1, ...factors);
+    return {
+        width: Math.max(1, Math.floor(size.width / factor)),
+        height: Math.max(1, Math.floor(size.height / factor)),
+    };
+}
+/** Re-encode preference for a source format the profile does not accept.
+ *  Alpha first: never trade transparency away for bytes. For opaque sources
+ *  JPEG leads because the per-image BYTE cap — not the pixel cap — is what a
+ *  lossless re-encode of a large photo most often blows; PNG is the last
+ *  resort there: lossless, and by far the largest wire form. */
+const ALPHA_TARGETS = ['image/png', 'image/webp', 'image/jpeg'];
+const OPAQUE_TARGETS = ['image/jpeg', 'image/webp', 'image/png'];
+/** Background composited under an alpha channel when the only writable
+ *  target carries no transparency. White matches the screenshots and document
+ *  captures this gate mostly sees; sharp's default composite is BLACK, which
+ *  reads as a broken image on any light UI. */
+const OPAQUE_BACKGROUND = { r: 255, g: 255, b: 255 };
+/**
+ * The media type one re-encode should produce.
+ *
+ * 1. A source format the profile already accepts is kept: re-encoding a format
+ *    nobody objected to costs quality (JPEG) or losslessness (PNG) for
+ *    nothing.
+ * 2. Otherwise the first accepted entry of the alpha/opaque order above. An
+ *    empty allowlist falls back to the source format, which the caller's own
+ *    admission check then refuses with the established message.
+ */
+function chooseTargetMediaType(input) {
+    const { hasAlpha, sourceMediaType, acceptedMediaTypes } = input;
+    if (acceptedMediaTypes.includes(sourceMediaType))
+        return sourceMediaType;
+    return (hasAlpha ? ALPHA_TARGETS : OPAQUE_TARGETS).find(type => acceptedMediaTypes.includes(type))
+        ?? sourceMediaType;
+}
+/** Load sharp lazily so a missing optionalDependency stays a typed outcome. */
+async function loadSharp() {
+    try {
+        // The ESM build exposes the factory as the namespace's default; some
+        // bundlers hand the function itself. Handle both without trusting either.
+        const mod = await import('sharp');
+        if (typeof mod === 'function')
+            return mod;
+        if (typeof mod === 'object' && mod !== null) {
+            const candidate = mod.default;
+            if (typeof candidate === 'function')
+                return candidate;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Produce bytes the profile can admit, and report what had to change.
+ *
+ * Both triggers are size-independent by design: a media type the profile does
+ * not accept is converted even when it fits the pixel caps (a small PNG must
+ * not be refused while a large one succeeds), and an image the byte probe
+ * cannot measure is decoded so its real dimensions decide. The probe still
+ * short-circuits the common case — bytes it proves to be inside the caps in an
+ * accepted format are returned untouched, with no encoder loaded.
+ *
+ * Aspect ratio is preserved by {@link downscaleTarget}. An animated source is
+ * REFUSED whenever this gate would have to touch its bytes: re-encoding a
+ * multi-page image here cannot promise frames, delays and loop survive, and
+ * silently returning a still is a data loss the store's own refusal (the
+ * behaviour without this gate) never inflicted. Animated images that need no
+ * change pass through untouched.
+ */
+export async function adaptImageForAdmission(bytes, sourceMediaType, limits, acceptedMediaTypes) {
+    const probe = probeImageSize(bytes);
+    const sharp = await loadSharp();
+    if (sharp === null) {
+        return { kind: 'unavailable', reason: 'sharp-missing', detail: 'sharp is not installed in this environment' };
+    }
+    try {
+        // One header read drives every decision below: dimensions for a format
+        // the byte probe cannot measure (the #432 gap), alpha support, and the
+        // frame count that decides whether this gate may touch the bytes at all.
+        const image = sharp(bytes);
+        const meta = await image.metadata();
+        const measured = probe ?? (meta.width !== undefined && meta.height !== undefined
+            ? { width: meta.width, height: meta.height }
+            : null);
+        if (measured === null) {
+            return { kind: 'unavailable', reason: 'decode-failed', detail: 'the image decodes without pixel dimensions' };
+        }
+        const hasAlpha = meta.hasAlpha === true;
+        const resized = !withinDimensionLimits(measured, limits);
+        if (!resized && acceptedMediaTypes.includes(sourceMediaType))
+            return { kind: 'unchanged' };
+        if ((meta.pages ?? 1) > 1) {
+            return {
+                kind: 'unavailable',
+                reason: 'animated-unsupported',
+                detail: `${meta.pages} frames`,
+            };
+        }
+        const mediaType = chooseTargetMediaType({ hasAlpha, sourceMediaType, acceptedMediaTypes });
+        const target = downscaleTarget(measured, limits);
+        const flattened = hasAlpha && mediaType === 'image/jpeg';
+        let pipeline = image;
+        if (resized)
+            pipeline = image.resize(target.width, target.height, { fit: 'inside' });
+        if (flattened)
+            pipeline = pipeline.flatten({ background: OPAQUE_BACKGROUND });
+        const data = await pipeline
+            .toFormat(mediaType.replace('image/', ''), mediaType === 'image/jpeg' ? { quality: 90 } : {})
+            .toBuffer();
+        return {
+            kind: 'adapted',
+            data,
+            mediaType,
+            width: target.width,
+            height: target.height,
+            resized,
+            flattened,
+        };
+    }
+    catch (error) {
+        return {
+            kind: 'unavailable',
+            reason: 'decode-failed',
+            detail: error instanceof Error ? error.message : String(error),
+        };
+    }
+}

package/lib/types/utils/intl.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Memoized `Intl.Segmenter` with grapheme granularity for width-aware string
+ * handling in the renderer and terminal parser.
+ * @returns The shared grapheme segmenter, created once on first use.
+ */
+export declare function getGraphemeSegmenter(): Intl.Segmenter;
+//# sourceMappingURL=intl.d.ts.map

package/lib/types/utils/intl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intl.d.ts","sourceRoot":"","sources":["../../../src/utils/intl.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,wBAAgB,oBAAoB,IAAI,IAAI,CAAC,SAAS,CAErD"}

package/lib/types/utils/intl.js

@@ -0,0 +1,9 @@
+let graphemeSegmenter;
+/**
+ * Memoized `Intl.Segmenter` with grapheme granularity for width-aware string
+ * handling in the renderer and terminal parser.
+ * @returns The shared grapheme segmenter, created once on first use.
+ */
+export function getGraphemeSegmenter() {
+    return (graphemeSegmenter ??= new Intl.Segmenter('en', { granularity: 'grapheme' }));
+}

package/lib/types/utils/keymap.d.ts

@@ -0,0 +1,138 @@
+/**
+ * Built-in keyboard-shortcut keymap: the shared combo grammar, the action
+ * registry, and the live override cache behind `/settings` customization.
+ *
+ * Split of concerns across the input stack:
+ * - `dsh-adapter/shortcuts.ts` owns the PLUGIN registry (`ctx.tuiShortcuts`)
+ *   and re-exports the grammar from here so both sides parse identically.
+ * - This module owns what the TUI itself binds: a fixed set of named actions
+ *   (paste, history, editor, …) whose combos resolve as
+ *   settings.yaml user layer > cordis.yml `shortcuts` > the registry default.
+ * `Chat.tsx` / `PromptInput.tsx` match keypresses against the EFFECTIVE
+ * combos via {@link actionMatches} — never against a hardcoded string.
+ *
+ * The macOS modifier alias mirrors `isMod`: a combo spelled with `ctrl`
+ * matches Cmd (`super`) on the mac too, so `ctrl+v` keeps meaning "paste
+ * with the platform primary modifier" everywhere. `alt` always means the
+ * ink `meta` flag. Shift must match exactly (ctrl+shift+v is the terminal's
+ * native paste, never the app's clipboard read).
+ */
+/** Minimal structural shape of the ink Key flags the matchers read. */
+export interface ComboKeyFlags {
+    ctrl?: boolean;
+    meta?: boolean;
+    super?: boolean;
+    shift?: boolean;
+    return?: boolean;
+    escape?: boolean;
+    tab?: boolean;
+    backspace?: boolean;
+    delete?: boolean;
+    upArrow?: boolean;
+    downArrow?: boolean;
+    leftArrow?: boolean;
+    rightArrow?: boolean;
+    home?: boolean;
+    end?: boolean;
+    pageUp?: boolean;
+    pageDown?: boolean;
+}
+/** A parsed `ctrl+shift+p` style combo. */
+export interface ParsedCombo {
+    readonly raw: string;
+    readonly ctrl: boolean;
+    readonly meta: boolean;
+    readonly shift: boolean;
+    /** Named key flag on the Key object, or undefined for a character key. */
+    readonly named?: keyof ComboKeyFlags;
+    /** Character to match against the ink `input` string (lowercased). */
+    readonly char?: string;
+}
+/**
+ * Parse `ctrl+shift+p` style combos. Returns undefined on anything
+ * malformed or disallowed (no ctrl/alt modifier, unknown key name, escape
+ * combos — the same grammar the plugin shortcut registry enforces).
+ */
+export declare function parseCombo(raw: string): ParsedCombo | undefined;
+/** Canonical form for dedupe/reserved checks: modifiers sorted, key last. */
+export declare function canonicalCombo(combo: ParsedCombo): string;
+/** Canonicalize a user-spelled combo string (`ctrl+c`); unparseable input
+ *  comes back lowercased as-is so reserved sets can still carry entries the
+ *  grammar itself refuses (bare escape, tab…). */
+export declare function canonicalComboString(raw: string): string;
+/**
+ * Strict matcher (plugin registry semantics): every modifier flag must equal
+ * the combo's. `ctrl` means the ctrl flag only — no platform alias.
+ */
+export declare function comboMatchesStrict(combo: ParsedCombo, input: string, key: ComboKeyFlags): boolean;
+/** Identifiers of every customizable built-in action. */
+export type ShortcutActionId = 'paste' | 'history' | 'editor' | 'transcript' | 'trajectory' | 'dashboard' | 'contextPanel' | 'showAll' | 'questionFold' | 'redraw' | 'todoFold' | 'expandEditor';
+export interface ShortcutActionSpec {
+    readonly id: ShortcutActionId;
+    /** Default combos; the FIRST entry is the canonical display form. */
+    readonly defaults: readonly string[];
+}
+/**
+ * The registry. Defaults encode today's hard-wired bindings — `paste` also
+ * carries the `alt+v` alias for terminals that intercept Ctrl+V before the
+ * app ever sees the byte (some terminals/IMEs reserve Ctrl+V for their own
+ * paste and never forward it in raw mode).
+ */
+export declare const SHORTCUT_ACTIONS: readonly ShortcutActionSpec[];
+/**
+ * Replace the whole override map. Invalid or blank entries are DROPPED
+ * (the action keeps its default) — a typo in cordis.yml must never disable
+ * a built-in, and the settings field's parse already refuses invalid
+ * drafts before anything is written.
+ */
+export declare function setKeymapOverrides(overrides: Partial<Record<ShortcutActionId, string | readonly string[] | undefined>>): void;
+/** Test seam: drop every override. */
+export declare function resetKeymapOverrides(): void;
+/** Effective combos for one action (overrides win over defaults). */
+export declare function effectiveCombos(action: ShortcutActionId): readonly ParsedCombo[];
+/** Effective combos as display strings (`ctrl+v, alt+v`). */
+export declare function effectiveComboString(action: ShortcutActionId): string;
+/** One combo in display capitalization ('ctrl+k' → 'Ctrl+K'). */
+export declare function comboDisplay(raw: string): string;
+/** Effective combos as display strings ('Ctrl+K, Alt+V'). */
+export declare function effectiveComboDisplay(action: ShortcutActionId): string;
+/** Match a keypress against an action's EFFECTIVE combos (platform alias
+ *  included). This is the one call site Chat/PromptInput should need. */
+export declare function actionMatches(action: ShortcutActionId, input: string, key: ComboKeyFlags): boolean;
+/**
+ * Parse user draft text for a settings field: one or more combos separated
+ * by commas/semicolons (spaces around separators tolerated). Empty/blank
+ * text means "restore the default" ({ combos: [] }); a malformed token makes
+ * the whole draft undefined (invalid — the settings screen blocks the save).
+ */
+export declare function parseComboDraft(text: string): {
+    combos: string[];
+} | undefined;
+/**
+ * Canonical combos the TUI binds but users canNOT remap — interrupt/exit,
+ * the readline-style editor keys, the newline variants, and the navigation
+ * keys plugins must never shadow. The customizable action combos (see
+ * {@link SHORTCUT_ACTIONS}) join this set dynamically wherever both are
+ * consulted. Entries the combo grammar itself refuses (bare escape, tab,
+ * shift+tab) stay listed verbatim for the lowercase fallback canonical.
+ */
+export declare const FIXED_RESERVED_COMBOS: readonly string[];
+/** The fixed reserved set in canonical form (shared with the adapter registry). */
+export declare function fixedReservedCombos(): ReadonlySet<string>;
+/** Whether a user-spelled combo hits a binding that no remap can free. */
+export declare function isFixedReserved(raw: string): boolean;
+/**
+ * Draft-time conflict check for the settings fields: a combo is unusable
+ * when it is fixed-reserved, or when some OTHER action currently binds it
+ * (its own action's defaults are fine to restate). Without this a remap
+ * like history → ctrl+v would silently shadow paste at match time.
+ */
+export declare function draftComboConflicts(action: ShortcutActionId, combos: readonly string[]): boolean;
+/**
+ * Canonical combos every customizable action currently binds (defaults ∪
+ * overrides) — the `dsh-adapter` plugin registry folds these into its
+ * reserved set so a plugin can never shadow a built-in, however the user
+ * remapped it.
+ */
+export declare function reservedActionCombos(): ReadonlySet<string>;
+//# sourceMappingURL=keymap.d.ts.map

package/lib/types/utils/keymap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keymap.d.ts","sourceRoot":"","sources":["../../../src/utils/keymap.ts"],"names":[],"mappings":"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"}