hyacinth-ai 0.9.6

package/dist/ui/chat-log.js

@@ -0,0 +1,246 @@
+import { Container, Spacer, Text } from '@earendil-works/pi-tui';
+import { theme } from './theme.js';
+import { AssistantMessageComponent } from './assistant-message.js';
+import { ToolExecutionComponent } from './tool-execution.js';
+import { UserMessageComponent } from './user-message.js';
+import { DiffComponent } from './diff-component.js';
+const MAX_COMPONENTS = 200;
+export class ChatLog extends Container {
+    maxComponents;
+    toolById = new Map();
+    streamingRuns = new Map();
+    toolsExpanded = false;
+    repeatableSystemMessage = null;
+    _scrollOffset = 0;
+    _viewportHeight = 40;
+    _pinnedToBottom = true;
+    _unreadCount = 0;
+    constructor(maxComponents = MAX_COMPONENTS) {
+        super();
+        this.maxComponents = Math.max(20, Math.floor(maxComponents));
+    }
+    dropComponentReferences(component) {
+        for (const [toolId, tool] of this.toolById.entries()) {
+            if (tool === component)
+                this.toolById.delete(toolId);
+        }
+        for (const [runId, message] of this.streamingRuns.entries()) {
+            if (message === component)
+                this.streamingRuns.delete(runId);
+        }
+        if (this.repeatableSystemMessage?.component === component) {
+            this.repeatableSystemMessage = null;
+        }
+    }
+    pruneOverflow() {
+        while (this.children.length > this.maxComponents) {
+            const oldest = this.children[0];
+            if (!oldest)
+                return;
+            this.removeChild(oldest);
+            this.dropComponentReferences(oldest);
+        }
+    }
+    append(component) {
+        this.addChild(component);
+        this.pruneOverflow();
+        if (!this._pinnedToBottom) {
+            this._unreadCount += 1;
+        }
+    }
+    appendNonSystem(component) {
+        this.repeatableSystemMessage = null;
+        this.append(component);
+    }
+    formatRepeatedSystemText(text, count) {
+        return count > 1 ? `${text} x${count}` : text;
+    }
+    createSystemMessage(text) {
+        const entry = new Container();
+        const textNode = new Text(theme.system(text), 1, 0);
+        entry.addChild(new Spacer(1));
+        entry.addChild(textNode);
+        return { component: entry, textNode, baseText: text, count: 1 };
+    }
+    addSystem(text, opts) {
+        if (opts?.coalesceConsecutive &&
+            this.repeatableSystemMessage?.baseText === text &&
+            this.children[this.children.length - 1] === this.repeatableSystemMessage.component) {
+            this.repeatableSystemMessage.count += 1;
+            this.repeatableSystemMessage.textNode.setText(theme.system(this.formatRepeatedSystemText(text, this.repeatableSystemMessage.count)));
+            return;
+        }
+        const message = this.createSystemMessage(text);
+        this.append(message.component);
+        this.repeatableSystemMessage = opts?.coalesceConsecutive ? message : null;
+    }
+    addUser(text) {
+        this.appendNonSystem(new UserMessageComponent(text));
+    }
+    resolveRunId(runId) {
+        return runId ?? 'default';
+    }
+    startAssistant(text, runId) {
+        const effectiveRunId = this.resolveRunId(runId);
+        const existing = this.streamingRuns.get(effectiveRunId);
+        if (existing) {
+            existing.setText(text);
+            return existing;
+        }
+        const component = new AssistantMessageComponent(text);
+        this.streamingRuns.set(effectiveRunId, component);
+        this.appendNonSystem(component);
+        return component;
+    }
+    updateAssistant(text, runId) {
+        const effectiveRunId = this.resolveRunId(runId);
+        const existing = this.streamingRuns.get(effectiveRunId);
+        if (!existing) {
+            this.startAssistant(text, runId);
+            return;
+        }
+        existing.setText(text);
+    }
+    finalizeAssistant(text, runId) {
+        const effectiveRunId = this.resolveRunId(runId);
+        const existing = this.streamingRuns.get(effectiveRunId);
+        if (existing) {
+            existing.setText(text);
+            this.streamingRuns.delete(effectiveRunId);
+            return;
+        }
+        this.appendNonSystem(new AssistantMessageComponent(text));
+    }
+    dropAssistant(runId) {
+        const effectiveRunId = this.resolveRunId(runId);
+        const existing = this.streamingRuns.get(effectiveRunId);
+        if (!existing)
+            return;
+        this.removeChild(existing);
+        this.streamingRuns.delete(effectiveRunId);
+    }
+    startTool(toolCallId, toolName, args) {
+        const existing = this.toolById.get(toolCallId);
+        if (existing) {
+            existing.setArgs(args);
+            return existing;
+        }
+        const component = new ToolExecutionComponent(toolName, args);
+        component.setExpanded(this.toolsExpanded);
+        this.toolById.set(toolCallId, component);
+        this.appendNonSystem(component);
+        return component;
+    }
+    updateToolArgs(toolCallId, args) {
+        const existing = this.toolById.get(toolCallId);
+        if (!existing)
+            return;
+        existing.setArgs(args);
+    }
+    updateToolResult(toolCallId, result, opts) {
+        const existing = this.toolById.get(toolCallId);
+        if (!existing)
+            return;
+        const text = typeof result === 'string' ? result : JSON.stringify(result);
+        if (opts?.partial) {
+            existing.setPartialResult(text);
+            return;
+        }
+        existing.setResult(text, { isError: opts?.isError });
+    }
+    showDiff(_toolId, filePath, diffLines) {
+        const diff = new DiffComponent(filePath, diffLines);
+        this.addChild(diff);
+    }
+    setToolsExpanded(expanded) {
+        this.toolsExpanded = expanded;
+        for (const tool of this.toolById.values()) {
+            tool.setExpanded(expanded);
+        }
+    }
+    toggleToolsExpanded() {
+        this.setToolsExpanded(!this.toolsExpanded);
+        return this.toolsExpanded;
+    }
+    getToolsExpanded() {
+        return this.toolsExpanded;
+    }
+    clearAll() {
+        this.clear();
+        this.toolById.clear();
+        this.streamingRuns.clear();
+        this.repeatableSystemMessage = null;
+        this._scrollOffset = 0;
+        this._pinnedToBottom = true;
+        this._unreadCount = 0;
+    }
+    getContentLines() {
+        const lines = [];
+        const collect = (comp) => {
+            if (comp instanceof Text) {
+                const text = comp.text ?? '';
+                lines.push(text);
+            }
+        };
+        const walk = (container) => {
+            if (!container.children)
+                return;
+            for (const child of container.children) {
+                collect(child);
+                if (child instanceof Container)
+                    walk(child);
+            }
+        };
+        walk(this);
+        return lines;
+    }
+    getLineCount() {
+        let count = 0;
+        for (const line of this.getContentLines()) {
+            count += line.split('\n').length;
+        }
+        return count;
+    }
+    setViewportHeight(height) {
+        this._viewportHeight = Math.max(1, height);
+    }
+    scrollToLine(line) {
+        const totalLines = this.getLineCount();
+        const maxOffset = Math.max(0, totalLines - this._viewportHeight);
+        if (line < 0) {
+            this._scrollOffset = Math.max(0, this._scrollOffset + line);
+            // User scrolled up → detach from bottom
+            if (this._scrollOffset < maxOffset) {
+                this._pinnedToBottom = false;
+            }
+        }
+        else if (line >= totalLines) {
+            this._scrollOffset = maxOffset;
+            this._pinnedToBottom = true;
+            this._unreadCount = 0;
+        }
+        else {
+            this._scrollOffset = Math.min(Math.max(0, line), maxOffset);
+            if (line < maxOffset) {
+                this._pinnedToBottom = false;
+            }
+        }
+    }
+    /** Pin to bottom (called on End key or user requesting bottom) */
+    pinToBottom() {
+        const maxOffset = Math.max(0, this.getLineCount() - this._viewportHeight);
+        this._scrollOffset = maxOffset;
+        this._pinnedToBottom = true;
+        this._unreadCount = 0;
+    }
+    get isPinnedToBottom() {
+        return this._pinnedToBottom;
+    }
+    get unreadCount() {
+        return this._unreadCount;
+    }
+    get scrollOffset() {
+        return this._scrollOffset;
+    }
+}
+//# sourceMappingURL=chat-log.js.map

package/dist/ui/command-registry.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Command Registry — 统一斜杠命令注册中心
+ *
+ * 命令来源：
+ *   1. BUILTIN — 内置命令（硬编码兜底）
+ *   2. USER — commands.json（用户/模型可写，热重载）
+ *
+ * 合并规则：同名命令 USER 覆盖 BUILTIN
+ */
+import { EventEmitter } from 'node:events';
+export type SlashCommandCategory = 'session' | 'model' | 'tools' | 'system' | 'config' | 'repair' | 'mode';
+export interface SlashCommandDef {
+    name: string;
+    description: string;
+    icon: string;
+    category: SlashCommandCategory;
+    args?: string;
+    argOptions?: string[];
+    executeLocal?: boolean;
+    /** 二级子命令（有 children 的命令在 TUI 中弹出选择面板而非直接执行） */
+    children?: SlashCommandDef[];
+    /** 动态子命令提供者（返回 Promise，在面板打开时调用。优先于 children） */
+    childrenProvider?: () => Promise<SlashCommandDef[]>;
+    /** 标记为已弃用（在 /help 中灰色显示） */
+    deprecated?: boolean;
+    /** 命令处理器（格式：module.method，如 localModel.start） */
+    handler?: string;
+}
+export declare const CATEGORY_LABELS: Record<SlashCommandCategory, string>;
+/**
+ * 命令注册中心 — 单例
+ *
+ * 合并内置命令 + 外部配置命令，支持热重载。
+ * 模型可以通过 write/edit 工具修改 commands.json 来增删命令。
+ */
+export declare class CommandRegistry extends EventEmitter {
+    private static _instance;
+    private mergedCommands;
+    private userCommands;
+    private configPath;
+    private constructor();
+    /** 获取单例 */
+    static getInstance(projectDir?: string): CommandRegistry;
+    /** 重新加载配置（热重载入口） */
+    reload(): void;
+    /** 从 commands.json 加载用户定义命令 */
+    private loadUserCommands;
+    /** 合并内置命令 + 用户命令（同名用户覆盖内置，递归合并 children） */
+    private merge;
+    /** 递归合并子命令列表（按 name 去重，用户覆盖内置） */
+    private mergeChildren;
+    /** 获取全部命令 */
+    getAll(): SlashCommandDef[];
+    /** 获取用户自定义命令 */
+    getUserCommands(): SlashCommandDef[];
+    /** 获取命令配置文件路径 */
+    getConfigPath(): string;
+    /** 按分类分组（含子命令，继承父命令分类） */
+    getByCategory(): Map<SlashCommandCategory, SlashCommandDef[]>;
+    /** 搜索过滤（递归搜索子命令） */
+    filter(query: string): SlashCommandDef[];
+    /** 递归检查子命令中是否有匹配项 */
+    private childMatches;
+    /** 按名称查找（支持 "parent/child" 格式） */
+    find(name: string): SlashCommandDef | undefined;
+    /** 查找命令的父命令（如果它是子命令） */
+    findParent(childName: string): SlashCommandDef | undefined;
+    /** 将包含 children 的命令展开为扁平列表（用于 AI prompt 等场景，全部直达可调用） */
+    flattenCommands(): SlashCommandDef[];
+    /** 按完整路径查找（含子命令层级），返回完整路径 */
+    resolvePath(input: string): SlashCommandDef | undefined;
+}
+//# sourceMappingURL=command-registry.d.ts.map