@askdkc/dsh-cli 0.11.3

package/lib/types/utils/keymap.js

@@ -0,0 +1,351 @@
+/**
+ * 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).
+ */
+import { isMac } from './modifiers.js';
+const NAMED_KEYS = {
+    enter: 'return',
+    return: 'return',
+    esc: 'escape',
+    escape: 'escape',
+    tab: 'tab',
+    backspace: 'backspace',
+    delete: 'delete',
+    up: 'upArrow',
+    down: 'downArrow',
+    left: 'leftArrow',
+    right: 'rightArrow',
+    home: 'home',
+    end: 'end',
+    pageup: 'pageUp',
+    pagedown: 'pageDown',
+};
+/**
+ * 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 function parseCombo(raw) {
+    const parts = String(raw ?? '')
+        .toLowerCase()
+        .split('+')
+        .map(part => part.trim())
+        .filter(part => part !== '');
+    if (parts.length === 0)
+        return undefined;
+    let ctrl = false;
+    let meta = false;
+    let shift = false;
+    let named;
+    let char;
+    for (const part of parts) {
+        if (part === 'ctrl' || part === 'control') {
+            if (ctrl)
+                return undefined;
+            ctrl = true;
+        }
+        else if (part === 'alt' || part === 'meta' || part === 'option') {
+            if (meta)
+                return undefined;
+            meta = true;
+        }
+        else if (part === 'shift') {
+            if (shift)
+                return undefined;
+            shift = true;
+        }
+        else if (part === 'space') {
+            if (char !== undefined || named !== undefined)
+                return undefined;
+            char = ' ';
+        }
+        else if (part in NAMED_KEYS) {
+            if (char !== undefined || named !== undefined)
+                return undefined;
+            named = NAMED_KEYS[part];
+        }
+        else if ([...part].length === 1) {
+            if (char !== undefined || named !== undefined)
+                return undefined;
+            char = part;
+        }
+        else {
+            return undefined;
+        }
+    }
+    if (char === undefined && named === undefined)
+        return undefined;
+    // Bare keys are typing/navigation; a modifier is what makes a shortcut.
+    if (!ctrl && !meta)
+        return undefined;
+    // Escape is fully owned by the TUI (every Escape arrives with meta set on
+    // the input layer), so escape combos can never be unambiguous.
+    if (named === 'escape')
+        return undefined;
+    return { raw: parts.join('+'), ctrl, meta, shift, ...(named === undefined ? {} : { named }), ...(char === undefined ? {} : { char }) };
+}
+/** Canonical form for dedupe/reserved checks: modifiers sorted, key last. */
+export function canonicalCombo(combo) {
+    const mods = [combo.ctrl ? 'ctrl' : '', combo.meta ? 'alt' : '', combo.shift ? 'shift' : '']
+        .filter(part => part !== '')
+        .sort();
+    return [...mods, combo.named === undefined ? (combo.char ?? '') : String(combo.named)].join('+');
+}
+/** 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 function canonicalComboString(raw) {
+    const combo = parseCombo(raw);
+    return combo === undefined ? String(raw ?? '').toLowerCase() : canonicalCombo(combo);
+}
+/**
+ * Strict matcher (plugin registry semantics): every modifier flag must equal
+ * the combo's. `ctrl` means the ctrl flag only — no platform alias.
+ */
+export function comboMatchesStrict(combo, input, key) {
+    if (Boolean(key.ctrl) !== combo.ctrl)
+        return false;
+    if (Boolean(key.meta) !== combo.meta)
+        return false;
+    if (key.super)
+        return false;
+    if (Boolean(key.shift) !== combo.shift)
+        return false;
+    if (combo.named !== undefined) {
+        return key[combo.named] === true;
+    }
+    if (combo.char === undefined)
+        return false;
+    return input.toLowerCase() === combo.char;
+}
+/**
+ * Built-in matcher with the platform primary-modifier alias: `ctrl` combos
+ * also accept Cmd (`super`) on macOS (isMod semantics), `alt` maps to the
+ * ink `meta` flag. Shift stays exact — ctrl+shift+v must keep meaning the
+ * terminal's native paste, never the app's clipboard read.
+ */
+function comboMatchesBuiltin(combo, input, key) {
+    const primary = key.ctrl === true || (isMac && key.super === true);
+    if (combo.ctrl !== primary)
+        return false;
+    if (Boolean(key.meta) !== combo.meta)
+        return false;
+    if (Boolean(key.shift) !== combo.shift)
+        return false;
+    if (combo.named !== undefined) {
+        return key[combo.named] === true;
+    }
+    if (combo.char === undefined)
+        return false;
+    return input.toLowerCase() === combo.char;
+}
+/**
+ * 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 const SHORTCUT_ACTIONS = [
+    { id: 'paste', defaults: ['ctrl+v', 'alt+v'] },
+    { id: 'history', defaults: ['ctrl+r'] },
+    { id: 'editor', defaults: ['ctrl+g'] },
+    { id: 'transcript', defaults: ['ctrl+o'] },
+    { id: 'trajectory', defaults: ['ctrl+t'] },
+    { id: 'dashboard', defaults: ['ctrl+a'] },
+    { id: 'contextPanel', defaults: ['ctrl+p'] },
+    { id: 'showAll', defaults: ['ctrl+e'] },
+    { id: 'redraw', defaults: ['ctrl+l'] },
+    { id: 'todoFold', defaults: ['ctrl+q'] },
+    { id: 'questionFold', defaults: ['ctrl+k'] },
+    { id: 'expandEditor', defaults: ['ctrl+shift+e'] },
+];
+const DEFAULT_COMBO_MAP = new Map(SHORTCUT_ACTIONS.map(action => [action.id, action.defaults.map(parseCombo).filter((combo) => combo !== undefined)]));
+/** Live overrides (settings user layer + cordis.yml merged by plugin.ts). */
+let overrideMap = new Map();
+/**
+ * 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 function setKeymapOverrides(overrides) {
+    const next = new Map();
+    for (const action of SHORTCUT_ACTIONS) {
+        const raw = overrides[action.id];
+        if (raw === undefined)
+            continue;
+        const list = (Array.isArray(raw) ? raw : [raw])
+            .flatMap(entry => String(entry).split(/[,;]/))
+            .map(entry => entry.trim())
+            .filter(entry => entry !== '');
+        const parsed = list.map(parseCombo).filter((combo) => combo !== undefined);
+        if (parsed.length === 0)
+            continue;
+        next.set(action.id, parsed);
+    }
+    overrideMap = next;
+}
+/** Test seam: drop every override. */
+export function resetKeymapOverrides() {
+    overrideMap = new Map();
+}
+/** Effective combos for one action (overrides win over defaults). */
+export function effectiveCombos(action) {
+    return overrideMap.get(action) ?? DEFAULT_COMBO_MAP.get(action) ?? [];
+}
+/** Effective combos as display strings (`ctrl+v, alt+v`). */
+export function effectiveComboString(action) {
+    return effectiveCombos(action).map(combo => combo.raw).join(', ');
+}
+/** Modifier token → display label ('ctrl' → 'Ctrl'). */
+const COMBO_MODIFIER_LABELS = {
+    ctrl: 'Ctrl',
+    shift: 'Shift',
+    alt: 'Alt',
+    meta: 'Meta',
+    super: 'Super',
+};
+/** One combo in display capitalization ('ctrl+k' → 'Ctrl+K'). */
+export function comboDisplay(raw) {
+    return raw.split('+').map(token => {
+        const lower = token.toLowerCase();
+        const mod = COMBO_MODIFIER_LABELS[lower];
+        if (mod !== undefined)
+            return mod;
+        return token.length === 1 ? token.toUpperCase() : token[0].toUpperCase() + token.slice(1);
+    }).join('+');
+}
+/** Effective combos as display strings ('Ctrl+K, Alt+V'). */
+export function effectiveComboDisplay(action) {
+    return effectiveCombos(action).map(combo => comboDisplay(combo.raw)).join(', ');
+}
+/** Match a keypress against an action's EFFECTIVE combos (platform alias
+ *  included). This is the one call site Chat/PromptInput should need. */
+export function actionMatches(action, input, key) {
+    const combos = effectiveCombos(action);
+    for (let index = 0; index < combos.length; index += 1) {
+        if (comboMatchesBuiltin(combos[index], input, key))
+            return true;
+    }
+    return false;
+}
+/**
+ * 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 function parseComboDraft(text) {
+    const trimmed = String(text ?? '').trim();
+    if (trimmed === '')
+        return { combos: [] };
+    const tokens = trimmed
+        .split(/[,;]/)
+        .map(token => token.trim())
+        .filter(token => token !== '');
+    if (tokens.length === 0)
+        return { combos: [] };
+    const combos = [];
+    for (const token of tokens) {
+        if (parseCombo(token) === undefined)
+            return undefined;
+        combos.push(token.toLowerCase());
+    }
+    return { combos };
+}
+/**
+ * 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 const FIXED_RESERVED_COMBOS = [
+    'ctrl+c', // interrupt / clear
+    'ctrl+d', // exit on empty input
+    'ctrl+e', // editor line end (also the showAll action's default)
+    'ctrl+a', // editor line start (also the dashboard action's default)
+    'ctrl+u', // kill line
+    'ctrl+k', // kill to end
+    'ctrl+w', // kill word
+    'ctrl+j', // newline fallback (legacy LF / extended key reporting)
+    'ctrl+left', // word jump
+    'ctrl+right', // word jump
+    'ctrl+return', // newline (multi-line input)
+    'ctrl+shift+return', // shift+Enter newline (CSI 13;6u) — same editor binding
+    'alt+return', // newline fallback on terminals without shift reporting
+    'alt+up', // pull the last pending message back for editing
+    'escape', // pickers / interrupt / rewind double-tap
+    'tab', // command completion
+    'shift+tab', // session-mode cycle
+];
+const FIXED_RESERVED_CANONICAL = new Set(FIXED_RESERVED_COMBOS.map(canonicalComboString));
+/** The fixed reserved set in canonical form (shared with the adapter registry). */
+export function fixedReservedCombos() {
+    return FIXED_RESERVED_CANONICAL;
+}
+/** Whether a user-spelled combo hits a binding that no remap can free. */
+export function isFixedReserved(raw) {
+    return FIXED_RESERVED_CANONICAL.has(canonicalComboString(raw));
+}
+/**
+ * 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 function draftComboConflicts(action, combos) {
+    const others = new Set();
+    const own = new Set();
+    for (const spec of SHORTCUT_ACTIONS) {
+        if (spec.id === action) {
+            // Restating a combo this action already binds — a default or the
+            // current override — changes nothing about what shadows what; it must
+            // not read as a conflict. This is what lets dashboard re-save its own
+            // ctrl+a default even though that combo is also fixed-reserved for
+            // the editor line-start (the dual-use the defaults themselves encode).
+            for (const raw of spec.defaults)
+                own.add(canonicalComboString(raw));
+            for (const combo of effectiveCombos(spec.id))
+                own.add(canonicalCombo(combo));
+            continue;
+        }
+        for (const combo of effectiveCombos(spec.id))
+            others.add(canonicalCombo(combo));
+    }
+    return combos.some(combo => {
+        if (own.has(canonicalComboString(combo)))
+            return false;
+        return isFixedReserved(combo) || others.has(canonicalComboString(combo));
+    });
+}
+/**
+ * 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 function reservedActionCombos() {
+    const reserved = new Set();
+    for (const action of SHORTCUT_ACTIONS) {
+        for (const combo of effectiveCombos(action.id))
+            reserved.add(canonicalCombo(combo));
+    }
+    return reserved;
+}

package/lib/types/utils/loaded-context.d.ts

@@ -0,0 +1,25 @@
+import type { LoadedContext } from '../dsh-adapter/channel.js';
+/** Per-entry display cap: `/context` shows the beginning of long texts. */
+export declare const CONTEXT_ENTRY_MAX_CHARS = 800;
+/**
+ * Truncate one entry's text for the panel body. The model-visible text is
+ * the source of truth; the local report only bounds its own rendering.
+ * @param text - the interpolated model-visible text.
+ * @param max - character cap, defaults to {@link CONTEXT_ENTRY_MAX_CHARS}.
+ * @returns the text, or its head plus a truncation marker.
+ */
+export declare function truncateContextText(text: string, max?: number): string;
+/**
+ * One-line collapsed summary of a loaded-context snapshot, naming only the
+ * non-empty groups (`${t('context-sections', { n: context.sections.length })} · ${t('context-files', { n: context.files.length })} · ${t('context-skills', { n: context.skills.length })} · ${t('context-tools', { n: context.tools.length })}`).
+ * @param context - the loaded-context snapshot.
+ * @returns the summary, or `''` when every group is empty.
+ */
+export declare function summarizeLoadedContext(context: LoadedContext): string;
+/**
+ * Format the loaded-context snapshot for the local `/context` report.
+ * The report preserves the former startup panel's grouping and truncation
+ * without keeping a second expandable surface in the transcript header.
+ */
+export declare function formatLoadedContextReport(context: LoadedContext): string[];
+//# sourceMappingURL=loaded-context.d.ts.map

package/lib/types/utils/loaded-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loaded-context.d.ts","sourceRoot":"","sources":["../../../src/utils/loaded-context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAA;AAG9D,2EAA2E;AAC3E,eAAO,MAAM,uBAAuB,MAAM,CAAA;AAE1C;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,SAA0B,GAAG,MAAM,CAGvF;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,aAAa,GAAG,MAAM,CAQrE;AAED;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,aAAa,GAAG,MAAM,EAAE,CA6B1E"}

package/lib/types/utils/loaded-context.js

@@ -0,0 +1,72 @@
+import { t } from '../i18n.js';
+/** Per-entry display cap: `/context` shows the beginning of long texts. */
+export const CONTEXT_ENTRY_MAX_CHARS = 800;
+/**
+ * Truncate one entry's text for the panel body. The model-visible text is
+ * the source of truth; the local report only bounds its own rendering.
+ * @param text - the interpolated model-visible text.
+ * @param max - character cap, defaults to {@link CONTEXT_ENTRY_MAX_CHARS}.
+ * @returns the text, or its head plus a truncation marker.
+ */
+export function truncateContextText(text, max = CONTEXT_ENTRY_MAX_CHARS) {
+    if (text.length <= max)
+        return text;
+    return `${text.slice(0, max)}${t('context-truncated')}`;
+}
+/**
+ * One-line collapsed summary of a loaded-context snapshot, naming only the
+ * non-empty groups (`${t('context-sections', { n: context.sections.length })} · ${t('context-files', { n: context.files.length })} · ${t('context-skills', { n: context.skills.length })} · ${t('context-tools', { n: context.tools.length })}`).
+ * @param context - the loaded-context snapshot.
+ * @returns the summary, or `''` when every group is empty.
+ */
+export function summarizeLoadedContext(context) {
+    const parts = [];
+    if (context.sections.length > 0)
+        parts.push(t('context-sections', { n: context.sections.length }));
+    if (context.files.length > 0)
+        parts.push(t('context-files', { n: context.files.length }));
+    if (context.contexts.length > 0)
+        parts.push(t('context-runtime', { n: context.contexts.length }));
+    if (context.skills.length > 0)
+        parts.push(t('context-skills', { n: context.skills.length }));
+    if (context.tools.length > 0)
+        parts.push(t('context-tools', { n: context.tools.length }));
+    return parts.join(' · ');
+}
+/**
+ * Format the loaded-context snapshot for the local `/context` report.
+ * The report preserves the former startup panel's grouping and truncation
+ * without keeping a second expandable surface in the transcript header.
+ */
+export function formatLoadedContextReport(context) {
+    const lines = [];
+    const appendEntry = (name, text, max = CONTEXT_ENTRY_MAX_CHARS) => {
+        lines.push(`  ${name}`);
+        lines.push(...truncateContextText(text, max).split('\n').map(line => `    ${line}`));
+    };
+    if (context.sections.length > 0) {
+        lines.push(t('context-panel-sections', { n: context.sections.length }));
+        for (const section of context.sections)
+            appendEntry(section.name, section.text);
+    }
+    if (context.files.length > 0) {
+        lines.push(t('context-panel-files', { n: context.files.length }));
+        lines.push(...context.files.map(file => `  ${file.displayPath}`));
+    }
+    if (context.contexts.length > 0) {
+        lines.push(t('context-panel-runtime', { n: context.contexts.length }));
+        for (const entry of context.contexts)
+            appendEntry(entry.name, entry.text);
+    }
+    if (context.skills.length > 0) {
+        lines.push(t('context-panel-skills', { n: context.skills.length }));
+        for (const skill of context.skills)
+            appendEntry(skill.name, skill.description);
+    }
+    if (context.tools.length > 0) {
+        lines.push(t('context-panel-tools', { n: context.tools.length }));
+        for (const tool of context.tools)
+            appendEntry(tool.name, tool.description, 160);
+    }
+    return lines;
+}

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

@@ -0,0 +1,7 @@
+/**
+ * Error logger for the renderer. Always writes to stderr so a render failure
+ * never passes silently.
+ * @param error - The error to log; its stack trace when available.
+ */
+export declare function logError(error: unknown): void;
+//# sourceMappingURL=log.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"log.d.ts","sourceRoot":"","sources":["../../../src/utils/log.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAG7C"}

package/lib/types/utils/log.js

@@ -0,0 +1,9 @@
+/**
+ * Error logger for the renderer. Always writes to stderr so a render failure
+ * never passes silently.
+ * @param error - The error to log; its stack trace when available.
+ */
+export function logError(error) {
+    const text = error instanceof Error ? error.stack ?? error.message : String(error);
+    process.stderr.write(`[dsh-tui] ${text}\n`);
+}

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

@@ -0,0 +1,53 @@
+/**
+ * `@` file-mention parsing (issue #15).
+ *
+ * A mention is an `@` that starts a whitespace-delimited token (string start
+ * or after whitespace) — `hello@world` never triggers. The token body is
+ * either a run of non-whitespace characters (`@src/a.ts`) or a double-quoted
+ * path (`@"my dir/a.ts"`, for paths containing spaces).
+ *
+ * A token may carry a trailing line-range suffix (issue #359):
+ * `@src/a.ts#L12` / `@src/a.ts#L12-14` (also after a quoted body:
+ * `@"my dir/a.ts"#L3-5`). The suffix must anchor at the token END and match
+ * `#L<digits>` / `#L<digits>-<digits>` exactly, so legal filenames that merely
+ * contain `#` (`report#L12.md`) never trip it; a range like `#L14-12` is
+ * rejected (kept as a literal path). Resolution order is strip-first: the
+ * suffix-stripped `path` is tried, and the caller may fall back to `literal`
+ * (the typed body, suffix intact) when that misses.
+ */
+export interface MentionToken {
+    /** Start index of the `@` in the source text. */
+    start: number;
+    /** End index (exclusive) of the whole token, quote and suffix included. */
+    end: number;
+    /** The referenced path as typed (unquoted, no leading `@`, suffix stripped). */
+    path: string;
+    /** Present only when a line suffix was stripped: the typed body verbatim
+     * (unquoted, suffix intact) — the literal fallback path for resolution. */
+    literal?: string;
+    /** Inclusive 1-based first line of the `#L` suffix, when present. */
+    startLine?: number;
+    /** Inclusive 1-based last line of the `#L` suffix; equals `startLine`
+     * for the single-line form. */
+    endLine?: number;
+}
+/** Extract every `@` mention in `text` (typed order, duplicates kept out). */
+export declare function extractMentions(text: string): MentionToken[];
+/**
+ * The mention token the caret is currently editing, if any: an `@` token
+ * that starts at or before the caret with the caret inside it. Used by the
+ * prompt's completion trigger so `@` works mid-message, not only at the
+ * start of the input.
+ *
+ * `query` is the PATH portion only (a `#L12-14` suffix never leaks into
+ * it) and `pathEnd` marks where that portion ends, so completing a token
+ * like `@src/a.ts#L12` matches on `src/a.ts` and replaces up to (not past)
+ * the `#` — the typed line range survives acceptance.
+ */
+export declare function mentionAtCaret(value: string, cursor: number): {
+    start: number;
+    end: number;
+    query: string;
+    pathEnd?: number;
+} | undefined;
+//# sourceMappingURL=mentions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mentions.d.ts","sourceRoot":"","sources":["../../../src/utils/mentions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,MAAM,WAAW,YAAY;IAC3B,iDAAiD;IACjD,KAAK,EAAE,MAAM,CAAA;IACb,2EAA2E;IAC3E,GAAG,EAAE,MAAM,CAAA;IACX,gFAAgF;IAChF,IAAI,EAAE,MAAM,CAAA;IACZ;+EAC2E;IAC3E,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,qEAAqE;IACrE,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB;mCAC+B;IAC/B,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAoCD,8EAA8E;AAC9E,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,EAAE,CA+C5D;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,GACb;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAkB7E"}

package/lib/types/utils/mentions.js

@@ -0,0 +1,133 @@
+/**
+ * `@` file-mention parsing (issue #15).
+ *
+ * A mention is an `@` that starts a whitespace-delimited token (string start
+ * or after whitespace) — `hello@world` never triggers. The token body is
+ * either a run of non-whitespace characters (`@src/a.ts`) or a double-quoted
+ * path (`@"my dir/a.ts"`, for paths containing spaces).
+ *
+ * A token may carry a trailing line-range suffix (issue #359):
+ * `@src/a.ts#L12` / `@src/a.ts#L12-14` (also after a quoted body:
+ * `@"my dir/a.ts"#L3-5`). The suffix must anchor at the token END and match
+ * `#L<digits>` / `#L<digits>-<digits>` exactly, so legal filenames that merely
+ * contain `#` (`report#L12.md`) never trip it; a range like `#L14-12` is
+ * rejected (kept as a literal path). Resolution order is strip-first: the
+ * suffix-stripped `path` is tried, and the caller may fall back to `literal`
+ * (the typed body, suffix intact) when that misses.
+ */
+/** True when `ch` delimits a token (whitespace). Path separators and the
+ *  quote char are ordinary token characters on every platform — Windows
+ *  backslash paths must survive both caret tracking and submission. */
+const isBoundary = (ch) => ch === undefined || /\s/.test(ch);
+/** Line-suffix shape: `#L7` or `#L7-9`, anchored at the token end. */
+const LINE_SUFFIX = /#L(\d+)(?:-(\d+))?$/;
+/**
+ * Split a trailing `#L7` / `#L7-9` suffix off an unquoted token body.
+ * Returns undefined when there is no suffix or the suffix is malformed
+ * (`#L0`, `#L9-7`, bare `#L12` with an empty path) — the caller then treats
+ * the body as a plain literal path, exactly as before issue #359.
+ */
+function splitLineSuffix(raw) {
+    const match = LINE_SUFFIX.exec(raw);
+    if (match === null)
+        return undefined;
+    const path = raw.slice(0, match.index);
+    if (path === '')
+        return undefined;
+    const startLine = Number(match[1]);
+    const endLine = match[2] === undefined ? startLine : Number(match[2]);
+    if (!Number.isInteger(startLine) || !Number.isInteger(endLine))
+        return undefined;
+    if (startLine < 1 || endLine < startLine)
+        return undefined;
+    return { path, literal: raw, startLine, endLine };
+}
+/** Extract every `@` mention in `text` (typed order, duplicates kept out). */
+export function extractMentions(text) {
+    const tokens = [];
+    const seen = new Set();
+    let index = 0;
+    while (index < text.length) {
+        const at = text.indexOf('@', index);
+        if (at === -1)
+            break;
+        index = at + 1;
+        if (!isBoundary(text[at - 1]))
+            continue; // email-style `a@b`, mid-token
+        if (text[at + 1] === '"') {
+            const close = text.indexOf('"', at + 2);
+            if (close === -1)
+                continue; // unterminated quote — not a mention
+            const quoted = text.slice(at + 2, close);
+            // `#L` suffix may follow the closing quote and extends the token.
+            let end = close + 1;
+            let range;
+            if (quoted !== '' && text[close + 1] === '#') {
+                let suffixEnd = close + 1;
+                while (suffixEnd < text.length && !isBoundary(text[suffixEnd]))
+                    suffixEnd++;
+                // splitLineSuffix expects `path + suffix`; feeding it the quoted body
+                // plus the tail yields path === quoted and the typed literal.
+                range = splitLineSuffix(quoted + text.slice(close + 1, suffixEnd));
+                if (range !== undefined)
+                    end = suffixEnd;
+            }
+            const key = text.slice(at, end);
+            if (quoted !== '' && !seen.has(key)) {
+                seen.add(key);
+                tokens.push(range === undefined
+                    ? { start: at, end, path: quoted }
+                    : { start: at, end, path: quoted, literal: `${quoted}${text.slice(close + 1, end)}`, startLine: range.startLine, endLine: range.endLine });
+            }
+            index = end;
+            continue;
+        }
+        let end = at + 1;
+        while (end < text.length && !isBoundary(text[end]))
+            end++;
+        const raw = text.slice(at + 1, end);
+        // A bare `@` or another trigger char (`@@`) carries no path.
+        if (raw && !raw.startsWith('@') && !seen.has(raw)) {
+            seen.add(raw);
+            const range = splitLineSuffix(raw);
+            tokens.push(range === undefined
+                ? { start: at, end, path: raw }
+                : { start: at, end, path: range.path, literal: range.literal, startLine: range.startLine, endLine: range.endLine });
+        }
+    }
+    return tokens;
+}
+/**
+ * The mention token the caret is currently editing, if any: an `@` token
+ * that starts at or before the caret with the caret inside it. Used by the
+ * prompt's completion trigger so `@` works mid-message, not only at the
+ * start of the input.
+ *
+ * `query` is the PATH portion only (a `#L12-14` suffix never leaks into
+ * it) and `pathEnd` marks where that portion ends, so completing a token
+ * like `@src/a.ts#L12` matches on `src/a.ts` and replaces up to (not past)
+ * the `#` — the typed line range survives acceptance.
+ */
+export function mentionAtCaret(value, cursor) {
+    // Token start: scan back from the caret to the previous boundary.
+    let start = cursor;
+    while (start > 0 && !isBoundary(value[start - 1]))
+        start--;
+    if (value[start] !== '@')
+        return undefined;
+    // Quoted form: the caret must sit before the closing quote.
+    if (value[start + 1] === '"') {
+        const close = value.indexOf('"', start + 2);
+        if (close !== -1 && cursor > close)
+            return undefined;
+        return { start, end: close === -1 ? value.length : close + 1, query: value.slice(start + 2, cursor) };
+    }
+    // Token end: first boundary at/after the caret.
+    let end = cursor;
+    while (end < value.length && !isBoundary(value[end]))
+        end++;
+    const queryEnd = Math.min(cursor, end);
+    const range = splitLineSuffix(value.slice(start + 1, end));
+    const pathEnd = range === undefined ? end : start + 1 + range.path.length;
+    return { start, end, query: value.slice(start + 1, Math.min(queryEnd, pathEnd)), pathEnd: range === undefined ? undefined : pathEnd };
+}