hyacinth-ai 0.9.6

package/dist/ui/diff-component.d.ts

@@ -0,0 +1,14 @@
+/**
+ * DiffComponent — 渲染文件变更 diff（TUI 中显示，模型不参与）
+ *
+ * 用单个 Text 组件渲染全部 diff 内容，避免 Container 子组件间距导致空行。
+ */
+import { Container } from '@earendil-works/pi-tui';
+export interface DiffLineItem {
+    kind: string;
+    text: string;
+}
+export declare class DiffComponent extends Container {
+    constructor(filePath: string, lines: DiffLineItem[]);
+}
+//# sourceMappingURL=diff-component.d.ts.map

package/dist/ui/diff-component.js

@@ -0,0 +1,42 @@
+/**
+ * DiffComponent — 渲染文件变更 diff（TUI 中显示，模型不参与）
+ *
+ * 用单个 Text 组件渲染全部 diff 内容，避免 Container 子组件间距导致空行。
+ */
+import { Container, Text } from '@earendil-works/pi-tui';
+import { theme } from './theme.js';
+const MAX_WIDTH = 76;
+export class DiffComponent extends Container {
+    constructor(filePath, lines) {
+        super();
+        const out = [];
+        out.push(theme.accent(`── diff: ${filePath} ──`));
+        const indent = '  '; // 2-space indent for visual separation
+        const maxShow = 30;
+        for (let i = 0; i < Math.min(lines.length, maxShow); i++) {
+            const line = lines[i];
+            const text = truncate(line.text, MAX_WIDTH);
+            const display = indent + prefix(line.kind) + text;
+            const colorFn = colorForKind(line.kind);
+            out.push(colorFn(display));
+        }
+        if (lines.length > maxShow) {
+            out.push(theme.dim(indent + `… 还有 ${lines.length - maxShow} 行`));
+        }
+        // 单 Text，多行，避免 Container 子组件间距
+        this.addChild(new Text(out.join('\n')));
+    }
+}
+function prefix(kind) {
+    return kind === 'add' ? '+ ' : kind === 'del' ? '- ' : '  ';
+}
+function colorForKind(kind) {
+    return kind === 'add' ? theme.success
+        : kind === 'del' ? theme.error
+            : kind === 'header' ? theme.accent
+                : theme.dim;
+}
+function truncate(s, max) {
+    return s.length > max ? s.slice(0, max - 3) + '...' : s;
+}
+//# sourceMappingURL=diff-component.js.map

package/dist/ui/hyperlink-markdown.d.ts

@@ -0,0 +1,10 @@
+import type { Component, DefaultTextStyle, MarkdownTheme } from '@earendil-works/pi-tui';
+export declare class HyperlinkMarkdown implements Component {
+    private inner;
+    private urls;
+    constructor(text: string, paddingX: number, paddingY: number, theme: MarkdownTheme, options?: DefaultTextStyle);
+    render(width: number): string[];
+    setText(text: string): void;
+    invalidate(): void;
+}
+//# sourceMappingURL=hyperlink-markdown.d.ts.map

package/dist/ui/hyperlink-markdown.js

@@ -0,0 +1,21 @@
+import { Markdown } from '@earendil-works/pi-tui';
+import { addOsc8Hyperlinks, extractUrls } from './osc8-hyperlinks.js';
+export class HyperlinkMarkdown {
+    inner;
+    urls;
+    constructor(text, paddingX, paddingY, theme, options) {
+        this.inner = new Markdown(text, paddingX, paddingY, theme, options);
+        this.urls = extractUrls(text);
+    }
+    render(width) {
+        return addOsc8Hyperlinks(this.inner.render(width), this.urls);
+    }
+    setText(text) {
+        this.inner.setText(text);
+        this.urls = extractUrls(text);
+    }
+    invalidate() {
+        this.inner.invalidate();
+    }
+}
+//# sourceMappingURL=hyperlink-markdown.js.map

package/dist/ui/markdown-message.d.ts

@@ -0,0 +1,10 @@
+import { Container } from '@earendil-works/pi-tui';
+import { HyperlinkMarkdown } from './hyperlink-markdown.js';
+type MarkdownOptions = ConstructorParameters<typeof HyperlinkMarkdown>[4];
+export declare class MarkdownMessageComponent extends Container {
+    private body;
+    constructor(text: string, y: number, options?: MarkdownOptions);
+    setText(text: string): void;
+}
+export {};
+//# sourceMappingURL=markdown-message.d.ts.map

package/dist/ui/markdown-message.js

@@ -0,0 +1,16 @@
+import { Container, Spacer } from '@earendil-works/pi-tui';
+import { markdownTheme } from './theme.js';
+import { HyperlinkMarkdown } from './hyperlink-markdown.js';
+export class MarkdownMessageComponent extends Container {
+    body;
+    constructor(text, y, options) {
+        super();
+        this.body = new HyperlinkMarkdown(text, 0, y, markdownTheme, options);
+        this.addChild(new Spacer(1));
+        this.addChild(this.body);
+    }
+    setText(text) {
+        this.body.setText(text);
+    }
+}
+//# sourceMappingURL=markdown-message.js.map

package/dist/ui/osc8-hyperlinks.d.ts

@@ -0,0 +1,4 @@
+export declare function wrapOsc8(url: string, text: string): string;
+export declare function extractUrls(markdown: string): string[];
+export declare function addOsc8Hyperlinks(lines: string[], urls: string[]): string[];
+//# sourceMappingURL=osc8-hyperlinks.d.ts.map

package/dist/ui/osc8-hyperlinks.js

@@ -0,0 +1,142 @@
+const SGR_PATTERN = '\\x1b\\[[0-9;]*m';
+const OSC8_PATTERN = '\\x1b\\]8;;.*?(?:\\x07|\\x1b\\\\)';
+const ANSI_RE = new RegExp(`${SGR_PATTERN}|${OSC8_PATTERN}`, 'g');
+const SGR_START_RE = new RegExp(`^${SGR_PATTERN}`);
+const OSC8_START_RE = new RegExp(`^${OSC8_PATTERN}`);
+export function wrapOsc8(url, text) {
+    return `\x1b]8;;${url}\x07${text}\x1b]8;;\x07`;
+}
+export function extractUrls(markdown) {
+    const urls = new Set();
+    const mdLinkRe = /\[(?:[^\]]*)\]\(\s*<?(https?:\/\/[^)\s>]+)>?(?:\s+["'][^"']*["'])?\s*\)/g;
+    let m;
+    while ((m = mdLinkRe.exec(markdown)) !== null) {
+        urls.add(m[1]);
+    }
+    const stripped = markdown.replace(/\[(?:[^\]]*)\]\(\s*<?https?:\/\/[^)\s>]+>?(?:\s+["'][^"']*["'])?\s*\)/g, '');
+    const bareRe = /https?:\/\/[^\s)\]>]+/g;
+    while ((m = bareRe.exec(stripped)) !== null) {
+        urls.add(m[0]);
+    }
+    return [...urls];
+}
+function stripAnsiForHyperlink(input) {
+    return input.replace(ANSI_RE, '');
+}
+function findUrlRanges(visibleText, knownUrls, pending) {
+    const ranges = [];
+    let newPending = null;
+    let searchFrom = 0;
+    if (pending) {
+        const remaining = pending.url.slice(pending.consumed);
+        const trimmed = visibleText.trimStart();
+        const leadingSpaces = visibleText.length - trimmed.length;
+        let matchLen = 0;
+        for (let j = 0; j < remaining.length && j < trimmed.length; j++) {
+            if (remaining[j] === trimmed[j])
+                matchLen++;
+            else
+                break;
+        }
+        if (matchLen > 0) {
+            ranges.push({ start: leadingSpaces, end: leadingSpaces + matchLen, url: pending.url });
+            searchFrom = leadingSpaces + matchLen;
+            if (pending.consumed + matchLen < pending.url.length) {
+                newPending = { url: pending.url, consumed: pending.consumed + matchLen };
+            }
+        }
+    }
+    const urlRe = /https?:\/\/[^\s)\]>]+/g;
+    urlRe.lastIndex = searchFrom;
+    let match;
+    while ((match = urlRe.exec(visibleText)) !== null) {
+        const fragment = match[0];
+        const start = match.index;
+        let resolvedUrl = fragment;
+        let found = false;
+        for (const known of knownUrls) {
+            if (known === fragment) {
+                resolvedUrl = known;
+                found = true;
+                break;
+            }
+        }
+        if (!found) {
+            let bestLen = 0;
+            for (const known of knownUrls) {
+                if (known.startsWith(fragment) && known.length > bestLen) {
+                    resolvedUrl = known;
+                    bestLen = known.length;
+                    found = true;
+                }
+            }
+        }
+        if (!found) {
+            let bestLen = 0;
+            for (const known of knownUrls) {
+                if (fragment.startsWith(known) && known.length > bestLen)
+                    bestLen = known.length;
+            }
+        }
+        ranges.push({ start, end: start + fragment.length, url: resolvedUrl });
+        if (resolvedUrl.length > fragment.length && resolvedUrl.startsWith(fragment)) {
+            newPending = { url: resolvedUrl, consumed: fragment.length };
+        }
+    }
+    return { ranges, pending: newPending };
+}
+function applyOsc8Ranges(line, ranges) {
+    if (ranges.length === 0)
+        return line;
+    const urlAt = new Map();
+    for (const r of ranges) {
+        for (let p = r.start; p < r.end; p++)
+            urlAt.set(p, r.url);
+    }
+    let result = '';
+    let visiblePos = 0;
+    let activeUrl = null;
+    let i = 0;
+    while (i < line.length) {
+        if (line.charCodeAt(i) === 0x1b) {
+            const sgr = line.slice(i).match(SGR_START_RE);
+            if (sgr) {
+                result += sgr[0];
+                i += sgr[0].length;
+                continue;
+            }
+            const osc = line.slice(i).match(OSC8_START_RE);
+            if (osc) {
+                result += osc[0];
+                i += osc[0].length;
+                continue;
+            }
+        }
+        const targetUrl = urlAt.get(visiblePos) ?? null;
+        if (targetUrl !== activeUrl) {
+            if (activeUrl !== null)
+                result += '\x1b]8;;\x07';
+            if (targetUrl !== null)
+                result += `\x1b]8;;${targetUrl}\x07`;
+            activeUrl = targetUrl;
+        }
+        result += line[i];
+        visiblePos++;
+        i++;
+    }
+    if (activeUrl !== null)
+        result += '\x1b]8;;\x07';
+    return result;
+}
+export function addOsc8Hyperlinks(lines, urls) {
+    if (urls.length === 0)
+        return lines;
+    let pending = null;
+    return lines.map((line) => {
+        const visible = stripAnsiForHyperlink(line);
+        const result = findUrlRanges(visible, urls, pending);
+        pending = result.pending;
+        return applyOsc8Ranges(line, result.ranges);
+    });
+}
+//# sourceMappingURL=osc8-hyperlinks.js.map

package/dist/ui/pi-tui-editor.d.ts

@@ -0,0 +1,35 @@
+import { Editor } from '@earendil-works/pi-tui';
+export type CustomEditorCallbacks = {
+    onSubmit?: (text: string) => void;
+    onEscape?: () => void;
+    onCtrlC?: () => void;
+    onCtrlD?: () => void;
+    onCtrlL?: () => void;
+    onCtrlP?: () => void;
+    onAltEnter?: () => void;
+    onBackspaceOnEmpty?: () => void;
+};
+/**
+ * CustomEditor extends pi-tui's Editor with keybinding callbacks.
+ *
+ * Usage in tui.ts:
+ *   const editor = new CustomEditor(tui, editorTheme);
+ *   editor.onSubmit = submitHandler;
+ *   editor.onEscape = () => { ... };
+ *   editor.onCtrlC = () => { ... };
+ *
+ * The base Editor already handles multi-line editing, undo, and autocomplete
+ * dropdown rendering.  This subclass only adds keybinding dispatch.
+ */
+export declare class CustomEditor extends Editor {
+    onSubmit?: (text: string) => void;
+    onEscape?: () => void;
+    onCtrlC?: () => void;
+    onCtrlD?: () => void;
+    onCtrlL?: () => void;
+    onCtrlP?: () => void;
+    onAltEnter?: () => void;
+    onBackspaceOnEmpty?: () => void;
+    handleInput(data: string): void;
+}
+//# sourceMappingURL=pi-tui-editor.d.ts.map

package/dist/ui/pi-tui-editor.js

@@ -0,0 +1,79 @@
+import { Editor, Key, matchesKey } from '@earendil-works/pi-tui';
+/**
+ * CustomEditor extends pi-tui's Editor with keybinding callbacks.
+ *
+ * Usage in tui.ts:
+ *   const editor = new CustomEditor(tui, editorTheme);
+ *   editor.onSubmit = submitHandler;
+ *   editor.onEscape = () => { ... };
+ *   editor.onCtrlC = () => { ... };
+ *
+ * The base Editor already handles multi-line editing, undo, and autocomplete
+ * dropdown rendering.  This subclass only adds keybinding dispatch.
+ */
+export class CustomEditor extends Editor {
+    handleInput(data) {
+        // Alt+Enter: trigger alternative submit (e.g. multi-line mode toggle)
+        if (matchesKey(data, Key.alt('enter')) && this.onAltEnter) {
+            this.onAltEnter();
+            return;
+        }
+        // Ctrl+L: open model selector or clear screen
+        if (matchesKey(data, Key.ctrl('l')) && this.onCtrlL) {
+            this.onCtrlL();
+            return;
+        }
+        // Ctrl+P: open session/agent selector
+        if (matchesKey(data, Key.ctrl('p')) && this.onCtrlP) {
+            this.onCtrlP();
+            return;
+        }
+        // Escape: abort current operation, only when autocomplete is not visible
+        if (matchesKey(data, Key.escape) && this.onEscape && !this.isShowingAutocomplete()) {
+            this.onEscape();
+            return;
+        }
+        // Ctrl+C: clear input or exit
+        if (matchesKey(data, Key.ctrl('c')) && this.onCtrlC) {
+            this.onCtrlC();
+            return;
+        }
+        // Ctrl+D: exit on empty line
+        if (matchesKey(data, Key.ctrl('d'))) {
+            if (this.getText().length === 0 && this.onCtrlD) {
+                this.onCtrlD();
+            }
+            return;
+        }
+        // Enter: submit current text
+        if (matchesKey(data, Key.enter) && this.onSubmit) {
+            // When autocomplete is showing (e.g. slash commands), let base Editor
+            // handle completion first; it will applyCompletion then fall through to
+            // submit via its own onSubmit mechanism.
+            if (this.isShowingAutocomplete()) {
+                super.handleInput(data);
+                return;
+            }
+            // Use getExpandedText() to expand paste markers like "[paste #2 +32 lines]"
+            // into the actual pasted content. getText() returns raw text with markers.
+            const text = this.getExpandedText().trim();
+            if (text.length > 0) {
+                this.onSubmit(text);
+                this.setText('');
+            }
+            return;
+        }
+        // Backspace on empty input: notify owner (e.g. for queue cancellation)
+        if (matchesKey(data, Key.backspace) &&
+            this.getText().length === 0 &&
+            this.onBackspaceOnEmpty &&
+            !this.isShowingAutocomplete()) {
+            this.onBackspaceOnEmpty();
+            return;
+        }
+        // Delegate all other input to the base Editor (multi-line editing, undo,
+        // autocomplete navigation, Ctrl+Left/Right word jumps, etc.)
+        super.handleInput(data);
+    }
+}
+//# sourceMappingURL=pi-tui-editor.js.map

package/dist/ui/slash-commands.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Slash Command 定义接口 — 门面层
+ *
+ * 类型定义和查询函数委托到 CommandRegistry 单例，
+ * 命令数据由内置定义 + commands.json 外部配置合并而成，支持热重载。
+ */
+import { CATEGORY_LABELS } from './command-registry.js';
+import type { SlashCommandCategory, SlashCommandDef } from './command-registry.js';
+export type { SlashCommandCategory, SlashCommandDef };
+export { CATEGORY_LABELS };
+export declare function getSlashCommands(): SlashCommandDef[];
+export declare function getCommandsByCategory(): Map<SlashCommandCategory, SlashCommandDef[]>;
+export declare function filterCommands(query: string): SlashCommandDef[];
+export declare function findCommand(name: string): SlashCommandDef | undefined;
+export declare function getCategoryLabel(category: SlashCommandCategory): string;
+//# sourceMappingURL=slash-commands.d.ts.map

package/dist/ui/slash-commands.js

@@ -0,0 +1,29 @@
+/**
+ * Slash Command 定义接口 — 门面层
+ *
+ * 类型定义和查询函数委托到 CommandRegistry 单例，
+ * 命令数据由内置定义 + commands.json 外部配置合并而成，支持热重载。
+ */
+import { CommandRegistry, CATEGORY_LABELS } from './command-registry.js';
+export { CATEGORY_LABELS };
+// ─── Lazy registry access ──────────────────────────────────────────
+function registry() {
+    return CommandRegistry.getInstance();
+}
+// ─── Query Functions (delegate to registry) ────────────────────────
+export function getSlashCommands() {
+    return registry().getAll();
+}
+export function getCommandsByCategory() {
+    return registry().getByCategory();
+}
+export function filterCommands(query) {
+    return registry().filter(query);
+}
+export function findCommand(name) {
+    return registry().find(name);
+}
+export function getCategoryLabel(category) {
+    return CATEGORY_LABELS[category] || category;
+}
+//# sourceMappingURL=slash-commands.js.map

package/dist/ui/slash-panel.d.ts

@@ -0,0 +1,54 @@
+/**
+ * SlashSubPanel — 斜杠命令二级菜单浮层面板
+ *
+ * 当用户输入有 children 的斜杠命令（如 /model）时弹出，
+ * 使用 pi-tui SelectList 提供上下选择、回车确认、Esc 退出。
+ */
+import { type Component, SelectList } from '@earendil-works/pi-tui';
+import type { TUI } from '@earendil-works/pi-tui';
+import type { SlashCommandDef } from './command-registry.js';
+export interface SubPanelResult {
+    path: string;
+    command: SlashCommandDef;
+}
+export interface SlashSubPanelTheme {
+    title: (text: string) => string;
+    hint: (text: string) => string;
+    selectedPrefix: (text: string) => string;
+    selectedText: (text: string) => string;
+    description: (text: string) => string;
+    scrollInfo: (text: string) => string;
+    noMatch: (text: string) => string;
+}
+export declare const DEFAULT_PANEL_THEME: SlashSubPanelTheme;
+export declare class SlashSubPanel {
+    private container;
+    private selectList;
+    private promptText;
+    private resolved;
+    private tui;
+    private keyListenerId;
+    private items;
+    private readonly parentCommand;
+    private children;
+    private readonly parentName;
+    private readonly theme;
+    private parentPanel;
+    private childPanel;
+    private active;
+    private readonly fullPath;
+    constructor(parentCommand: SlashCommandDef, theme?: SlashSubPanelTheme, parentPanel?: SlashSubPanel | null, pathPrefix?: string);
+    getContainer(): Component;
+    getSelectList(): SelectList;
+    private buildItems;
+    show(tui: TUI, onResolve: (result: SubPanelResult | null) => void): Promise<void>;
+    /** 1. Open a child panel for a sub-command that has its own children */
+    private openChild;
+    /** Restore this panel after a child panel was dismissed via Esc */
+    private restoreFromChild;
+    /** Close this panel without resolving (used when Esc navigates up to parent) */
+    private close;
+    /** Terminal: resolve and clean up */
+    private dismiss;
+}
+//# sourceMappingURL=slash-panel.d.ts.map