@hunterzhu/pulse-cli 0.2.1 → 0.4.0

package/dist/hooks/useRun.js

@@ -39,8 +39,14 @@ export function useRun({ host, conversationId, addAssistantMessage, }) {
     const [isRunning, setIsRunning] = useState(false);
     const [currentStep, setCurrentStep] = useState(null);
     const [error, setError] = useState(null);
-    const [approvalRequest, setApprovalRequest] = useState(null);
-    const [askRequest, setAskRequest] = useState(null);
+    const [pendingInteractions, setPendingInteractions] = useState([]);
+    const enqueueInteraction = useCallback((item) => {
+        setPendingInteractions((current) => current.some((entry) => entry.request.effectId === item.request.effectId) ? current : [...current, item]);
+    }, []);
+    const removeInteraction = useCallback((effectId) => setPendingInteractions((current) => current.filter((entry) => entry.request.effectId !== effectId)), []);
+    const activeInteraction = pendingInteractions[0];
+    const approvalRequest = activeInteraction?.kind === 'approval' ? activeInteraction.request : null;
+    const askRequest = activeInteraction?.kind === 'ask' ? activeInteraction.request : null;
     const [approvalSubmitting, setApprovalSubmitting] = useState(false);
     const [lanes, setLanes] = useState([]);
     const runRef = useRef(null);
@@ -50,11 +56,30 @@ export function useRun({ host, conversationId, addAssistantMessage, }) {
             id: run.id,
             role: 'assistant',
             text: '',
+            streamStatus: 'streaming',
             createdAt: new Date().toISOString(),
             toolCalls: [],
             runId: run.id,
         };
         let assistantStarted = false;
+        let streamedEffectId;
+        let streamedAttemptId;
+        let lastProgressText = '';
+        const addProgress = (key, text) => {
+            if (!text || text === lastProgressText)
+                return;
+            lastProgressText = text;
+            addAssistantMessage({
+                // One live activity cell is updated in place, like Codex/Claude's
+                // active-turn transcript, instead of appending every snapshot.
+                id: `run-activity-${run.id}`,
+                role: 'system',
+                text,
+                createdAt: new Date().toISOString(),
+                runId: run.id,
+            }, key === 'finished' ? { moveToEnd: true } : undefined);
+        };
+        addProgress('received', '已收到任务，正在理解需求并安排步骤…');
         const ensureAssistant = () => {
             if (assistantStarted)
                 return;
@@ -68,6 +93,16 @@ export function useRun({ host, conversationId, addAssistantMessage, }) {
                     : {};
                 const text = typeof data.text === 'string' ? data.text : '';
                 if (text) {
+                    if (data.kind === 'task_progress') {
+                        const tasks = Array.isArray(data.tasks) ? data.tasks : [];
+                        const visibleText = tasks.length === 0 ? '正在理解需求并规划执行步骤…' : text;
+                        setCurrentStep(visibleText);
+                        const active = tasks.find((task) => task && typeof task === 'object' && ['running', 'verifying'].includes(String(task.status)));
+                        const stageKey = active ? `${String(active.id)}:${String(active.status)}:${String(active.goal)}` : visibleText.replace(/\s*[·|]\s*(阶段调用|stage calls)\s*\d+.*$/i, '');
+                        const stageText = visibleText.replace(/\s*[·|]\s*(阶段调用|stage calls)\s*\d+.*$/i, '');
+                        addProgress(`stage:${stageKey}`, stageText);
+                        continue;
+                    }
                     addAssistantMessage({
                         id: `notice-${run.id}-${event.seq}`,
                         role: 'system',
@@ -77,10 +112,37 @@ export function useRun({ host, conversationId, addAssistantMessage, }) {
                 }
                 continue;
             }
-            ensureAssistant();
+            if (event.type !== 'complete' && event.type !== 'error')
+                ensureAssistant();
             switch (event.type) {
+                case 'delta': {
+                    const delta = event.data && typeof event.data === 'object' && !Array.isArray(event.data)
+                        ? event.data
+                        : {};
+                    const effectId = typeof delta.effectId === 'string' ? delta.effectId : undefined;
+                    const attemptId = typeof delta.attemptId === 'string' ? delta.attemptId : undefined;
+                    const text = typeof delta.text === 'string' ? delta.text : '';
+                    if (!text)
+                        break;
+                    if (effectId !== streamedEffectId || attemptId !== streamedAttemptId) {
+                        assistantMessage.text = '';
+                        streamedEffectId = effectId;
+                        streamedAttemptId = attemptId;
+                    }
+                    assistantMessage.text += text;
+                    assistantMessage.streamStatus = 'streaming';
+                    addAssistantMessage({ ...assistantMessage, toolCalls: assistantMessage.toolCalls?.map((call) => ({ ...call })) });
+                    setCurrentStep('正在生成回复…');
+                    break;
+                }
                 case 'text':
-                    assistantMessage.text += String(event.data ?? '');
+                    if (streamedEffectId !== undefined)
+                        assistantMessage.text = String(event.data ?? '');
+                    else
+                        assistantMessage.text += String(event.data ?? '');
+                    streamedEffectId = undefined;
+                    streamedAttemptId = undefined;
+                    assistantMessage.streamStatus = 'complete';
                     addAssistantMessage({ ...assistantMessage, toolCalls: assistantMessage.toolCalls?.map((call) => ({ ...call })) });
                     break;
                 case 'observation': {
@@ -102,6 +164,8 @@ export function useRun({ host, conversationId, addAssistantMessage, }) {
                             ? calls.map((call, callIndex) => callIndex === index ? { ...call, ...nextCall } : call)
                             : [...calls, nextCall];
                         addAssistantMessage({ ...assistantMessage, toolCalls: assistantMessage.toolCalls.map((call) => ({ ...call })) });
+                        setCurrentStep(nextCall.status === 'succeeded' ? `已完成 ${nextCall.name}，正在整理结果…` : nextCall.status === 'failed' ? `${nextCall.name} 未成功，正在处理错误…` : `正在执行 ${nextCall.name}…`);
+                        addProgress(`tool-result:${id}:${nextCall.status}`, `${nextCall.status === 'succeeded' ? '已完成' : nextCall.status === 'cancelled' ? '已取消' : '执行失败'} · ${nextCall.name}`);
                     }
                     break;
                 }
@@ -122,22 +186,21 @@ export function useRun({ host, conversationId, addAssistantMessage, }) {
                                 return typeof item.label === 'string' && typeof item.value === 'string' ? [{ label: item.label, value: item.value }] : [];
                             })
                             : undefined;
-                        setApprovalRequest(null);
-                        setAskRequest({
-                            effectId,
-                            toolName: typeof input.toolName === 'string' ? input.toolName : `ask.${input.type}`,
-                            type: input.type,
-                            prompt: typeof input.prompt === 'string' ? input.prompt : '请输入你的回答。',
-                            ...(options && options.length ? { options } : {}),
-                            ...(typeof input.min === 'number' ? { min: input.min } : {}),
-                            ...(typeof input.max === 'number' ? { max: input.max } : {}),
-                            ...(typeof input.placeholder === 'string' ? { placeholder: input.placeholder } : {}),
-                            ...(typeof input.defaultValue === 'string' ? { defaultValue: input.defaultValue } : {}),
-                        });
+                        enqueueInteraction({ kind: 'ask', request: {
+                                effectId,
+                                toolName: typeof input.toolName === 'string' ? input.toolName : `ask.${input.type}`,
+                                type: input.type,
+                                prompt: typeof input.prompt === 'string' ? input.prompt : '请输入你的回答。',
+                                ...(options && options.length ? { options } : {}),
+                                ...(typeof input.min === 'number' ? { min: input.min } : {}),
+                                ...(typeof input.max === 'number' ? { max: input.max } : {}),
+                                ...(typeof input.placeholder === 'string' ? { placeholder: input.placeholder } : {}),
+                                ...(typeof input.defaultValue === 'string' ? { defaultValue: input.defaultValue } : {}),
+                            } });
                         setCurrentStep('等待你的回答...');
+                        addProgress(`waiting:${effectId}`, '等待你的回答…');
                         break;
                     }
-                    setAskRequest(null);
                     const tools = Array.isArray(input.tools)
                         ? input.tools.flatMap((tool) => {
                             if (!tool || typeof tool !== 'object' || Array.isArray(tool))
@@ -153,15 +216,16 @@ export function useRun({ host, conversationId, addAssistantMessage, }) {
                         })
                         : [];
                     const firstTool = tools[0];
-                    setApprovalRequest({
-                        effectId,
-                        toolName: tools.length === 1 ? firstTool.name : `${tools.length || 1} 个系统操作`,
-                        toolArgs: firstTool?.input ?? {},
-                        prompt: typeof input.prompt === 'string' ? input.prompt : '是否批准执行？',
-                        ...(typeof input.digest === 'string' ? { digest: input.digest } : {}),
-                        ...(tools.length ? { tools } : {}),
-                    });
+                    enqueueInteraction({ kind: 'approval', request: {
+                            effectId,
+                            toolName: tools.length === 1 ? firstTool.name : `${tools.length || 1} 个系统操作`,
+                            toolArgs: firstTool?.input ?? {},
+                            prompt: typeof input.prompt === 'string' ? input.prompt : '是否批准执行？',
+                            ...(typeof input.digest === 'string' ? { digest: input.digest } : {}),
+                            ...(tools.length ? { tools } : {}),
+                        } });
                     setCurrentStep('等待用户审批...');
+                    addProgress(`approval:${effectId}`, `等待审批 · ${tools.map((tool) => tool.name).join('、') || '系统操作'}`);
                     break;
                 }
                 case 'fact':
@@ -181,6 +245,29 @@ export function useRun({ host, conversationId, addAssistantMessage, }) {
                                         ...(typeof item.activity === 'string' ? { activity: item.activity } : {}),
                                     }];
                             }));
+                            const activeLanes = fact.lanes.filter((lane) => typeof lane.status === 'string' && !['succeeded', 'failed', 'cancelled'].includes(lane.status));
+                            const active = activeLanes.find((lane) => lane.activityKind === 'tool') ?? activeLanes[0];
+                            if (active && typeof active.goal === 'string') {
+                                const toolName = active.activityKind === 'tool' && typeof active.activity === 'string' ? active.activity : undefined;
+                                const activity = toolName ? `正在调用工具 · ${toolName}` : typeof active.activity === 'string'
+                                    ? active.activity === 'llm' ? '正在分析需求和已有证据…' : '正在处理任务…'
+                                    : '正在处理任务…';
+                                setCurrentStep(`${activity}：${active.goal}`);
+                                const activityId = toolName
+                                    ? (typeof active.activityEffectId === 'string' ? active.activityEffectId : active.id)
+                                    : active.activity === 'llm' ? 'analysis' : `${active.id}:${active.status}`;
+                                addProgress(`activity:${activityId}`, activity);
+                                if (toolName && typeof active.activityToolCallId === 'string') {
+                                    const id = active.activityToolCallId;
+                                    const calls = assistantMessage.toolCalls ?? [];
+                                    const index = calls.findIndex((call) => call.id === id);
+                                    const nextCall = { id, name: toolName, status: 'running', arguments: {} };
+                                    assistantMessage.toolCalls = index >= 0
+                                        ? calls.map((call, callIndex) => callIndex === index ? { ...call, ...nextCall } : call)
+                                        : [...calls, nextCall];
+                                    addAssistantMessage({ ...assistantMessage, toolCalls: assistantMessage.toolCalls.map((call) => ({ ...call })) });
+                                }
+                            }
                             break;
                         }
                     }
@@ -189,30 +276,43 @@ export function useRun({ host, conversationId, addAssistantMessage, }) {
                         setCurrentStep(describeFactStatus(event.data));
                     break;
                 case 'error':
+                    addProgress('finished', '运行遇到错误。');
+                    if (assistantStarted && assistantMessage.text) {
+                        assistantMessage.streamStatus = 'incomplete';
+                        addAssistantMessage({ ...assistantMessage, toolCalls: assistantMessage.toolCalls?.map((call) => ({ ...call })) });
+                    }
                     setError(String(event.data ?? '发生未知错误'));
                     setIsRunning(false);
                     setCurrentStep(null);
-                    setApprovalRequest(null);
-                    setAskRequest(null);
+                    setPendingInteractions([]);
                     setLanes([]);
                     break;
                 case 'complete':
+                    addProgress('finished', event.data && typeof event.data === 'object' && !Array.isArray(event.data) && event.data.status === 'succeeded' ? '任务处理完成。' : '任务已结束。');
                     setIsRunning(false);
                     setCurrentStep(null);
-                    setApprovalRequest(null);
-                    setAskRequest(null);
+                    setPendingInteractions([]);
                     if (event.data && typeof event.data === 'object' && !Array.isArray(event.data)) {
                         const completion = event.data;
+                        const accepted = completion.status === 'succeeded' && (!completion.taskOutcome || (typeof completion.taskOutcome === 'object' && completion.taskOutcome !== null && completion.taskOutcome.status === 'accepted'));
+                        if (assistantStarted && assistantMessage.text) {
+                            assistantMessage.streamStatus = accepted ? 'complete' : 'incomplete';
+                            addAssistantMessage({ ...assistantMessage, toolCalls: assistantMessage.toolCalls?.map((call) => ({ ...call })) });
+                        }
                         const usage = completion.usage && typeof completion.usage === 'object' && !Array.isArray(completion.usage)
                             ? completion.usage
                             : undefined;
                         if (usage) {
                             const input = typeof usage.inputTokens === 'number' ? usage.inputTokens.toLocaleString() : '未知';
                             const output = typeof usage.outputTokens === 'number' ? usage.outputTokens.toLocaleString() : '未知';
+                            const reasoning = typeof usage.reasoningTokens === 'number' ? usage.reasoningTokens.toLocaleString() : '未知';
+                            const visibleChars = typeof usage.visibleOutputChars === 'number' ? usage.visibleOutputChars.toLocaleString() : '未知';
+                            const modelCalls = typeof usage.modelCalls === 'number' ? usage.modelCalls.toLocaleString() : '未知';
+                            const truncations = typeof usage.truncationEvents === 'number' ? usage.truncationEvents.toLocaleString() : '未知';
                             const costs = Array.isArray(usage.providerCosts) ? usage.providerCosts.filter((item) => Boolean(item && typeof item === 'object' && typeof item.currency === 'string' && typeof item.amount === 'number')) : [];
                             const estimate = usage.estimatedCost && typeof usage.estimatedCost === 'object' ? usage.estimatedCost : undefined;
                             const costLabel = costs.length ? costs.map((item) => `${item.amount} ${item.currency}`).join(', ') : estimate && typeof estimate.amount === 'number' ? `估算 ${estimate.amount} ${String(estimate.currency)} (价格 ${String(estimate.pricingVersion)})` : '费用未知';
-                            addAssistantMessage({ id: `run-usage-${run.id}`, role: 'system', text: `用量：输入 ${input} · 输出 ${output} · ${costLabel}${usage.completeness === 'partial' ? ' · 数据不完整' : ''}`, createdAt: new Date().toISOString(), runId: run.id });
+                            addAssistantMessage({ id: `run-usage-${run.id}`, role: 'system', text: `用量：输入 ${input} · 输出 ${output} · 思考 ${reasoning} · 可见字符 ${visibleChars} · 模型调用 ${modelCalls} · 截断 ${truncations} · ${costLabel}${usage.completeness === 'partial' ? ' · 数据不完整' : ''}`, createdAt: new Date().toISOString(), runId: run.id });
                         }
                         const taskOutcome = completion.taskOutcome && typeof completion.taskOutcome === 'object' && !Array.isArray(completion.taskOutcome)
                             ? completion.taskOutcome
@@ -245,12 +345,11 @@ export function useRun({ host, conversationId, addAssistantMessage, }) {
                     break;
             }
         }
-    }, [addAssistantMessage]);
+    }, [addAssistantMessage, enqueueInteraction]);
     const finishRun = useCallback(() => {
         setIsRunning(false);
         setCurrentStep(null);
-        setApprovalRequest(null);
-        setAskRequest(null);
+        setPendingInteractions([]);
         runRef.current = null;
     }, []);
     const sendMessage = useCallback(async (text, targetConversationId) => {
@@ -270,7 +369,7 @@ export function useRun({ host, conversationId, addAssistantMessage, }) {
         }
         setIsRunning(true);
         setError(null);
-        setCurrentStep('思考中...');
+        setCurrentStep('正在理解你的需求并安排执行步骤…');
         try {
             const run = await host.sendMessage(activeConversationId, { text });
             await consumeRun(run);
@@ -288,7 +387,7 @@ export function useRun({ host, conversationId, addAssistantMessage, }) {
             return;
         setIsRunning(true);
         setError(null);
-        setCurrentStep('正在恢复未完成的运行...');
+        setCurrentStep('正在恢复任务进度…');
         try {
             const run = await host.resumeRun(activeConversationId);
             await consumeRun(run);
@@ -311,7 +410,7 @@ export function useRun({ host, conversationId, addAssistantMessage, }) {
         setApprovalSubmitting(true);
         try {
             await runRef.current.reply(effectId, { approved, ...(approved ? {} : { reason: reason || '拒绝执行' }) });
-            setApprovalRequest(null);
+            removeInteraction(effectId);
             setCurrentStep('审批已提交，正在继续...');
             setError(null);
         }
@@ -322,14 +421,14 @@ export function useRun({ host, conversationId, addAssistantMessage, }) {
         finally {
             setApprovalSubmitting(false);
         }
-    }, [approvalSubmitting]);
+    }, [approvalSubmitting, removeInteraction]);
     const replyAsk = useCallback(async (effectId, value) => {
         if (!effectId || !runRef.current || approvalSubmitting)
             return;
         setApprovalSubmitting(true);
         try {
             await runRef.current.reply(effectId, value);
-            setAskRequest(null);
+            removeInteraction(effectId);
             setCurrentStep('回答已提交，正在继续...');
             setError(null);
         }
@@ -340,7 +439,7 @@ export function useRun({ host, conversationId, addAssistantMessage, }) {
         finally {
             setApprovalSubmitting(false);
         }
-    }, [approvalSubmitting]);
+    }, [approvalSubmitting, removeInteraction]);
     const cancelRun = useCallback(async () => {
         if (runRef.current) {
             await runRef.current.cancel('USER_CANCELLED');

package/dist/hooks/useSlashCommands.d.ts

@@ -1,12 +1,12 @@
 import type { SlashCommand } from '../types.js';
 export interface SlashCommandDependencies {
     onMouse?: (args: string) => void | Promise<void>;
+    onCopy?: () => void | Promise<void>;
     onHelp?: () => void | Promise<void>;
     onStatus?: () => void | Promise<void>;
     onTools?: () => void | Promise<void>;
     onArtifacts?: () => void | Promise<void>;
     onExit?: () => void | Promise<void>;
-    onQuit?: () => void | Promise<void>;
     onCancel?: () => void | Promise<void>;
     onNew?: () => void | Promise<void>;
     onResume?: () => void | Promise<void>;

package/dist/hooks/useSlashCommands.js

@@ -2,12 +2,12 @@ import { useMemo, useCallback } from 'react';
 export function useSlashCommands(deps) {
     const commands = useMemo(() => [
         { name: '/mouse', description: '滚轮和触控板滚动 [on|off]', execute: async (args) => deps.onMouse?.(args) },
+        { name: '/copy', description: '复制选区或最近一条完整回复', execute: async () => deps.onCopy?.() },
         { name: '/help', aliases: ['/h'], description: '显示帮助信息', execute: async () => deps.onHelp?.() },
         { name: '/status', description: '查看状态', execute: async () => deps.onStatus?.() },
         { name: '/tools', description: '列出可用工具', execute: async () => deps.onTools?.() },
         { name: '/artifacts', description: '查看当前产物', execute: async () => deps.onArtifacts?.() },
         { name: '/exit', description: '退出程序', execute: async () => deps.onExit?.() },
-        { name: '/quit', aliases: ['/q'], description: '退出程序', execute: async () => deps.onQuit?.() },
         { name: '/cancel', aliases: ['/stop'], description: '取消当前运行（保留会话）', execute: async () => deps.onCancel?.() },
         { name: '/new', description: '开启新会话', execute: async () => deps.onNew?.() },
         { name: '/resume', description: '恢复上一次会话或未完成运行', execute: async () => deps.onResume?.() },

package/dist/types.d.ts

@@ -16,6 +16,7 @@ export interface DisplayMessage {
     id: string;
     role: MessageRole;
     text: string;
+    streamStatus?: 'streaming' | 'complete' | 'incomplete' | undefined;
     runId?: string | undefined;
     createdAt: string;
     /** 工具调用事件 */

package/dist/utils/clipboard.d.ts

@@ -0,0 +1,14 @@
+interface ClipboardCommand {
+    file: string;
+    args: string[];
+}
+export declare function isCopyShortcut(input: string, key: {
+    ctrl?: boolean;
+    meta?: boolean;
+}): boolean;
+export declare function clipboardCommands(platform?: NodeJS.Platform): ClipboardCommand[];
+/** Remove characters that look blank but become troublesome when pasted. */
+export declare function sanitizeClipboardText(text: string): string;
+/** Copy the complete plain-text payload through the host OS clipboard utility. */
+export declare function copyToClipboard(text: string): Promise<void>;
+export {};

package/dist/utils/clipboard.js

@@ -0,0 +1,49 @@
+import { spawn } from 'node:child_process';
+import { stripTerminalControls } from './ansi.js';
+export function isCopyShortcut(input, key) {
+    const value = input.toLowerCase();
+    return (key.meta === true && value === 'c') || (key.ctrl === true && (value === 'c' || input === '\u0003'));
+}
+export function clipboardCommands(platform = process.platform) {
+    if (platform === 'darwin')
+        return [{ file: 'pbcopy', args: [] }];
+    if (platform === 'win32')
+        return [{ file: 'clip.exe', args: [] }];
+    if (platform === 'linux')
+        return [{ file: 'wl-copy', args: [] }, { file: 'xclip', args: ['-selection', 'clipboard'] }];
+    return [];
+}
+/** Remove characters that look blank but become troublesome when pasted. */
+export function sanitizeClipboardText(text) {
+    return stripTerminalControls(text)
+        .replace(/\r\n?/g, '\n')
+        .replace(/[\u00A0\u202F]/g, ' ')
+        .replace(/[\u00AD\u200B\u2060\uFEFF]/g, '');
+}
+/** Copy the complete plain-text payload through the host OS clipboard utility. */
+export async function copyToClipboard(text) {
+    const cleanText = sanitizeClipboardText(text);
+    const commands = clipboardCommands();
+    if (!commands.length)
+        throw new Error('CLIPBOARD_UNSUPPORTED');
+    let lastError;
+    for (const command of commands) {
+        try {
+            await new Promise((resolve, reject) => {
+                const child = spawn(command.file, command.args, { stdio: ['pipe', 'ignore', 'pipe'] });
+                let stderr = '';
+                child.stderr.setEncoding('utf8');
+                child.stderr.on('data', (chunk) => { stderr += chunk; });
+                child.once('error', reject);
+                child.once('close', (code) => code === 0 ? resolve() : reject(new Error(stderr.trim() || `${command.file} exited with ${code}`)));
+                child.stdin.once('error', reject);
+                child.stdin.end(cleanText);
+            });
+            return;
+        }
+        catch (error) {
+            lastError = error;
+        }
+    }
+    throw Object.assign(new Error('CLIPBOARD_UNAVAILABLE'), { cause: lastError });
+}

package/dist/utils/inputHistory.d.ts

@@ -0,0 +1,11 @@
+export interface InputHistoryState {
+    entries: string[];
+    position: number | null;
+    draft: string;
+}
+export declare const emptyInputHistory: () => InputHistoryState;
+export declare function rememberInput(state: InputHistoryState, value: string): InputHistoryState;
+export declare function navigateInputHistory(state: InputHistoryState, direction: 'up' | 'down', currentValue: string): {
+    state: InputHistoryState;
+    value?: string;
+};

package/dist/utils/inputHistory.js

@@ -0,0 +1,24 @@
+export const emptyInputHistory = () => ({ entries: [], position: null, draft: '' });
+export function rememberInput(state, value) {
+    if (!value.trim())
+        return { ...state, position: null, draft: '' };
+    return { entries: [...state.entries, value].slice(-50), position: null, draft: '' };
+}
+export function navigateInputHistory(state, direction, currentValue) {
+    if (!state.entries.length)
+        return { state };
+    if (direction === 'up') {
+        const position = state.position === null
+            ? state.entries.length - 1
+            : Math.max(0, state.position - 1);
+        const draft = state.position === null ? currentValue : state.draft;
+        return { state: { ...state, position, draft }, value: state.entries[position] };
+    }
+    if (state.position === null)
+        return { state };
+    if (state.position < state.entries.length - 1) {
+        const position = state.position + 1;
+        return { state: { ...state, position }, value: state.entries[position] };
+    }
+    return { state: { ...state, position: null, draft: '' }, value: state.draft };
+}

package/dist/utils/mouse.d.ts

@@ -1,6 +1,11 @@
-/** SGR mouse reporting. Ink removes the first ESC before delivering unknown keys. */
-export declare function mouseEvent(input: string): {
+export interface TerminalMouseEvent {
+    x: number;
+    y: number;
+    button: number;
+    phase: 'press' | 'drag' | 'release' | 'wheel';
     wheel: number;
-} | undefined;
-export declare const enableMouse = "\u001B[?1000h\u001B[?1006h";
-export declare const disableMouse = "\u001B[?1006l\u001B[?1000l";
+}
+/** SGR mouse reporting. Ink removes the first ESC before delivering unknown keys. */
+export declare function mouseEvent(input: string): TerminalMouseEvent | undefined;
+export declare const enableMouse = "\u001B[?1002h\u001B[?1006h";
+export declare const disableMouse = "\u001B[?1006l\u001B[?1002l";

package/dist/utils/mouse.js

@@ -1,11 +1,21 @@
 /** SGR mouse reporting. Ink removes the first ESC before delivering unknown keys. */
 export function mouseEvent(input) {
-    const match = /^(?:\x1b)?\[<(\d+);\d+;\d+([Mm])$/.exec(input);
+    const match = /^(?:\x1b)?\[<(\d+);(\d+);(\d+)([Mm])$/.exec(input);
     if (!match)
         return undefined;
     const button = Number(match[1]);
+    const x = Number(match[2]) - 1;
+    const y = Number(match[3]) - 1;
+    const final = match[4];
     const base = button & ~28; // Shift, Alt and Ctrl modifiers do not change direction.
-    return { wheel: match[2] === 'M' && base === 64 ? -3 : match[2] === 'M' && base === 65 ? 3 : 0 };
+    if (base === 64 || base === 65)
+        return { x, y, button, phase: 'wheel', wheel: base === 64 ? -3 : 3 };
+    if (final === 'm' || (button & 3) === 3)
+        return { x, y, button, phase: 'release', wheel: 0 };
+    if ((button & 32) !== 0)
+        return { x, y, button, phase: 'drag', wheel: 0 };
+    return { x, y, button, phase: 'press', wheel: 0 };
 }
-export const enableMouse = '\x1b[?1000h\x1b[?1006h';
-export const disableMouse = '\x1b[?1006l\x1b[?1000l';
+// Button-event tracking reports press/release/drag while retaining wheel events.
+export const enableMouse = '\x1b[?1002h\x1b[?1006h';
+export const disableMouse = '\x1b[?1006l\x1b[?1002l';

package/dist/utils/selection.d.ts

@@ -0,0 +1,13 @@
+export interface TextPoint {
+    line: number;
+    column: number;
+}
+export interface TextSelection {
+    start: TextPoint;
+    end: TextPoint;
+}
+export declare function orderedSelection(selection: TextSelection): TextSelection;
+/** Returns the visible text rows in selection order, with terminal styling removed. */
+export declare function selectedText(lines: readonly string[], selection: TextSelection): string;
+/** Adds a calm, high-contrast selection without terminal reverse-video. */
+export declare function selectedLine(line: string, lineIndex: number, selection?: TextSelection): string;

package/dist/utils/selection.js

@@ -0,0 +1,107 @@
+import { stripTerminalControls } from './ansi.js';
+import chalk from 'chalk';
+function pointOrder(a, b) {
+    return a.line - b.line || a.column - b.column;
+}
+export function orderedSelection(selection) {
+    return pointOrder(selection.start, selection.end) <= 0
+        ? selection
+        : { start: selection.end, end: selection.start };
+}
+function isCombining(character) {
+    return /[\p{Mark}\u200D\uFE0E\uFE0F]/u.test(character);
+}
+function isWide(codePoint) {
+    return codePoint >= 0x1100 && (codePoint <= 0x115f || codePoint === 0x2329 || codePoint === 0x232a ||
+        (codePoint >= 0x2e80 && codePoint <= 0xa4cf && codePoint !== 0x303f) ||
+        (codePoint >= 0xac00 && codePoint <= 0xd7a3) ||
+        (codePoint >= 0xf900 && codePoint <= 0xfaff) ||
+        (codePoint >= 0xfe10 && codePoint <= 0xfe19) ||
+        (codePoint >= 0xfe30 && codePoint <= 0xfe6f) ||
+        (codePoint >= 0xff00 && codePoint <= 0xff60) ||
+        (codePoint >= 0xffe0 && codePoint <= 0xffe6) ||
+        (codePoint >= 0x1f300 && codePoint <= 0x1faff) ||
+        (codePoint >= 0x20000 && codePoint <= 0x3fffd));
+}
+function width(character) {
+    if (isCombining(character))
+        return 0;
+    const codePoint = character.codePointAt(0) ?? 0;
+    return isWide(codePoint) ? 2 : 1;
+}
+function indexAtColumn(text, column) {
+    let cells = 0;
+    let index = 0;
+    for (const character of text) {
+        const next = cells + width(character);
+        if (column < next)
+            return index;
+        cells = next;
+        index += character.length;
+    }
+    return text.length;
+}
+function indexAfterCellAtColumn(text, column) {
+    let cells = 0;
+    let index = 0;
+    for (const character of text) {
+        const next = cells + width(character);
+        if (column < next)
+            return index + character.length;
+        cells = next;
+        index += character.length;
+    }
+    return text.length;
+}
+function rawOffsetAtVisibleIndex(raw, target) {
+    const control = /^(?:\u001B\][\s\S]*?(?:\u0007|\u001B\\)|[\u001B\u009B][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]|\u001B[@-_])/u;
+    let offset = 0;
+    let visible = 0;
+    while (offset < raw.length) {
+        if (visible >= target)
+            return offset;
+        const remaining = raw.slice(offset);
+        const escape = control.exec(remaining);
+        if (escape) {
+            offset += escape[0].length;
+            continue;
+        }
+        const codePoint = raw.codePointAt(offset);
+        const character = String.fromCodePoint(codePoint);
+        if (!/[\u0000-\u001f\u007f-\u009f]/u.test(character))
+            visible += character.length;
+        offset += character.length;
+    }
+    return raw.length;
+}
+/** Returns the visible text rows in selection order, with terminal styling removed. */
+export function selectedText(lines, selection) {
+    const ordered = orderedSelection(selection);
+    const firstLine = Math.max(0, Math.min(lines.length - 1, ordered.start.line));
+    const lastLine = Math.max(firstLine, Math.min(lines.length - 1, ordered.end.line));
+    const result = [];
+    for (let line = firstLine; line <= lastLine; line++) {
+        const plain = stripTerminalControls(lines[line] ?? '');
+        const from = line === firstLine ? ordered.start.column : 0;
+        const start = indexAtColumn(plain, from);
+        const end = line === lastLine ? indexAfterCellAtColumn(plain, ordered.end.column) : plain.length;
+        result.push(plain.slice(Math.min(start, end), Math.max(start, end)));
+    }
+    return result.join('\n');
+}
+/** Adds a calm, high-contrast selection without terminal reverse-video. */
+export function selectedLine(line, lineIndex, selection) {
+    if (!selection)
+        return line;
+    const plain = stripTerminalControls(line);
+    const ordered = orderedSelection(selection);
+    if (lineIndex < ordered.start.line || lineIndex > ordered.end.line)
+        return line;
+    const from = lineIndex === ordered.start.line ? ordered.start.column : 0;
+    const start = indexAtColumn(plain, from);
+    const end = lineIndex === ordered.end.line ? indexAfterCellAtColumn(plain, ordered.end.column) : plain.length;
+    const mark = chalk.bgHex('#DDF4F1').hex('#173B3A');
+    const rawStart = rawOffsetAtVisibleIndex(line, start);
+    const rawEnd = rawOffsetAtVisibleIndex(line, end);
+    return `${line.slice(0, rawStart)}${mark(plain.slice(start, end))}${line.slice(rawEnd)}`;
+}