@xenosystem/agent-conversation 0.1.36 → 0.1.37

package/dist/components/agent/toolCallDerive.js

@@ -0,0 +1,741 @@
+import { extractWindowsFilePathsFromToolResult } from '../../utils/markdownWindowsPaths.js';
+import { compactCommandPreview, hideDuplicateToolTitle, isCommandToolCall } from './toolCardDisplay.js';
+export function countNormalizedTextLines(content) {
+    const normalized = content.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+    if (!normalized.length)
+        return 0;
+    return normalized.replace(/\n$/, '').split('\n').length;
+}
+export function normalizeEditorCandidatePath(raw) {
+    return raw
+        .trim()
+        .replace(/^["'`]+|["'`]+$/g, '')
+        .replace(/[)\].,;:]+$/g, '');
+}
+export function extractPathsFromResultText(text) {
+    return extractWindowsFilePathsFromToolResult(text)
+        .map(normalizeEditorCandidatePath)
+        .filter(Boolean);
+}
+export function deriveToolCallFilePath(toolCall) {
+    if (toolCall.diff?.path)
+        return normalizeEditorCandidatePath(toolCall.diff.path);
+    const artifactPath = toolCall.artifacts?.find((artifact) => artifact.type === 'file' && artifact.openInEditor)?.value;
+    if (artifactPath)
+        return normalizeEditorCandidatePath(artifactPath);
+    const params = toolCall.params || {};
+    const paramCandidates = [
+        params.path,
+        params.file_path,
+        params.targetPath,
+        params.resolvedTargetPath,
+    ];
+    for (const candidate of paramCandidates) {
+        if (typeof candidate === 'string') {
+            const normalized = normalizeEditorCandidatePath(candidate);
+            if (/^[A-Za-z]:\\/.test(normalized))
+                return normalized;
+        }
+    }
+    const resultCandidates = extractPathsFromResultText(toolCall.result || '');
+    return resultCandidates[0] || null;
+}
+export function humanizeToolName(toolName) {
+    return toolName
+        .replace(/_/g, ' ')
+        .replace(/([a-z])([A-Z])/g, '$1 $2')
+        .replace(/\b\w/g, (char) => char.toUpperCase());
+}
+export function stripToolDisplayPrefix(value) {
+    return value
+        .replace(/^(Selected folder:|Selecting folder:?|Workspace placement:|Running:|Searching:|Reading:|Writing:|Editing:)\s*/i, '')
+        .trim();
+}
+export function isToolDisplayNoise(value) {
+    const trimmed = (value || '').trim();
+    if (!trimmed)
+        return true;
+    if (/^[{}\[\],:]+$/.test(trimmed))
+        return true;
+    if (trimmed === '{}' || trimmed === '[]' || trimmed === 'null')
+        return true;
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (parsed === null)
+            return true;
+        if (Array.isArray(parsed))
+            return parsed.length === 0;
+        if (typeof parsed === 'object')
+            return Object.keys(parsed).length === 0;
+    }
+    catch {
+        // Not JSON, so only the punctuation-only check above applies.
+    }
+    return false;
+}
+export function deriveToolCardDisplay(toolCall) {
+    const params = toolCall.params || {};
+    const normalizedToolName = toolCall.toolName.toLowerCase();
+    const fallbackLabel = isToolDisplayNoise(toolCall.summary)
+        ? stripToolDisplayPrefix(toolCallLabel(toolCall.toolName, params))
+        : stripToolDisplayPrefix(toolCall.summary || '');
+    const pr = toolCall.permissionRequest;
+    const fileName = deriveToolCallFileName(toolCall);
+    const fileActionLabel = deriveFileToolActionLabel(toolCall);
+    const filePrimaryText = deriveFileToolPrimaryText(toolCall);
+    const query = typeof params.query === 'string' ? params.query.trim() : '';
+    const app = typeof params.app === 'string'
+        ? params.app.trim()
+        : (typeof params.appPath === 'string' ? params.appPath.trim() : '');
+    const directoryArtifact = toolCall.artifacts?.find((artifact) => artifact.type === 'directory')?.value;
+    const directory = typeof params.directory === 'string' && params.directory.trim()
+        ? params.directory.trim()
+        : directoryArtifact;
+    const choice = typeof params.choice === 'string' ? mapWorkspaceChoice(params.choice.trim()) : '';
+    const command = typeof params.command === 'string' ? params.command.trim() : '';
+    if (pr?.status === 'pending') {
+        return hideDuplicateToolTitle({
+            eyebrow: 'Approval required',
+            title: normalizedToolName === 'choosedirectory'
+                ? 'Open folder picker'
+                : (pr.directory || pr.path || fallbackLabel || humanizeToolName(toolCall.toolName)),
+        });
+    }
+    if (fileActionLabel) {
+        return hideDuplicateToolTitle({
+            eyebrow: filePrimaryText || `${fileActionLabel} file`,
+            title: `${fileActionLabel} ${fileName}`,
+        });
+    }
+    if (isCommandToolCall(toolCall)) {
+        return hideDuplicateToolTitle({
+            eyebrow: toolCall.status === 'running' ? 'Running command' : 'Command',
+            title: command ? compactCommandPreview(command) : 'Terminal command',
+        });
+    }
+    switch (normalizedToolName) {
+        case 'choosedirectory':
+            return hideDuplicateToolTitle({
+                eyebrow: toolCall.status === 'running' ? 'Selecting folder' : 'Selected folder',
+                title: toolCall.status === 'running'
+                    ? (directory || 'Selecting folder')
+                    : (directory || fallbackLabel || 'Choose a folder'),
+            });
+        case 'workspaceselection':
+            return hideDuplicateToolTitle({
+                eyebrow: 'Workspace action',
+                title: choice || fallbackLabel || 'Update workspace placement',
+            });
+        case 'chooseworkspaceplacement':
+            return {
+                eyebrow: toolCall.status === 'running' ? 'Choose workspace placement' : 'Workspace placement',
+                title: '',
+            };
+        case 'xenoworkspacemanage':
+            return hideDuplicateToolTitle({
+                eyebrow: 'Workspace registry',
+                title: fallbackLabel || 'Manage workspace hierarchy',
+            });
+        case 'glob':
+            return hideDuplicateToolTitle({
+                eyebrow: toolCall.status === 'running' ? 'Finding files' : 'Glob',
+                title: '',
+            });
+        case 'terminallist':
+            return hideDuplicateToolTitle({
+                eyebrow: toolCall.status === 'running' ? 'Terminal command' : 'Terminal command',
+                title: '',
+            });
+        case 'terminalreadoutput':
+            return hideDuplicateToolTitle({
+                eyebrow: toolCall.status === 'running' ? 'Terminal command' : 'Terminal command',
+                title: '',
+            });
+        case 'terminalwriteinput':
+            return hideDuplicateToolTitle({
+                eyebrow: 'Terminal command',
+                title: '',
+            });
+        case 'askuser':
+            return hideDuplicateToolTitle({
+                eyebrow: 'User input',
+                title: '',
+            });
+        case 'websearch':
+        case 'web_search':
+            return hideDuplicateToolTitle({
+                eyebrow: toolCall.status === 'running' ? 'Searching web' : 'Web search',
+                title: query || fallbackLabel || 'Search query',
+            });
+        case 'openapp':
+        case 'open_app':
+            return hideDuplicateToolTitle({
+                eyebrow: toolCall.status === 'running' ? 'Opening app' : 'Opened app',
+                title: app || fallbackLabel || 'App launch',
+            });
+        default:
+            return hideDuplicateToolTitle({
+                eyebrow: humanizeToolName(toolCall.toolName),
+                title: fallbackLabel || humanizeToolName(toolCall.toolName),
+            });
+    }
+}
+export function summarizeCommand(cmd) {
+    const lower = cmd.toLowerCase();
+    if (lower.startsWith('web_search:')) {
+        const query = cmd.slice(11).trim();
+        return { icon: 'search', label: `Searched web: ${query}`, detail: `Web search for "${query}"` };
+    }
+    if (lower.includes('select-string') || lower.includes('grep') || lower.includes('findstr')) {
+        const patternMatch = cmd.match(/[-"]Pattern["']?\s+["']?([^"'\s]+)/i) || cmd.match(/Select-String.*["']([^"']+)["']/i);
+        const pathMatch = cmd.match(/-Path\s+["']?([^"'\s|]+)/i);
+        const caseSensitive = lower.includes('casesensitive:$false') ? 'Case insensitive' : '';
+        const detail = `Searched with query ${patternMatch?.[1] || 'pattern'}${pathMatch ? ` in ${pathMatch[1]}` : ''}${caseSensitive ? `\n${caseSensitive}` : ''}`;
+        return { icon: 'search', label: `Searched ${patternMatch?.[1] || 'pattern'}`, detail };
+    }
+    if (lower.includes('get-childitem') || lower.includes('ls') || lower.includes('dir')) {
+        const pathMatch = cmd.match(/-Path\s+["']?([^"'\s|]+)/i) || cmd.match(/(?:ls|dir)\s+["']?([^"'\s|]+)/i);
+        const path = pathMatch?.[1] || '';
+        const folder = path.split(/[/\\]/).filter(Boolean).pop() || path;
+        const flags = [lower.includes('-recurse') && 'Recursive', lower.includes('-force') && 'Including hidden'].filter(Boolean).join(', ');
+        const detail = `Listed directory ${path}${flags ? `\n${flags}` : ''}`;
+        return { icon: 'file', label: `Listed ${folder || 'directory'}`, detail };
+    }
+    if (lower.includes('get-content') || lower.includes('cat') || lower.includes('type')) {
+        const pathMatch = cmd.match(/-Path\s+["']?([^"'\s|]+)/i) || cmd.match(/(?:cat|type)\s+["']?([^"'\s|]+)/i);
+        const path = pathMatch?.[1] || '';
+        const file = path.split(/[/\\]/).pop() || 'file';
+        return { icon: 'file', label: `Read ${file}`, detail: `Read file ${path}` };
+    }
+    const short = cmd.length > 60 ? cmd.slice(0, 57) + '...' : cmd;
+    return { icon: 'terminal', label: short, detail: cmd };
+}
+export function parseStructuredCommandContent(content) {
+    const raw = content.replace(/^```\n?/gm, '').replace(/```$/gm, '').trim();
+    if (!raw) {
+        return {
+            command: '',
+            cwd: '',
+            stdout: '',
+            stderr: '',
+            error: '',
+            exit: '',
+            outputLineCount: 0,
+        };
+    }
+    const lines = raw.split('\n');
+    let command = '';
+    let cwd = '';
+    let error = '';
+    let exit = '';
+    let inStderr = false;
+    const stdoutLines = [];
+    const stderrLines = [];
+    for (const line of lines) {
+        if (!command && line.startsWith('$ ')) {
+            command = line.slice(2).trim();
+            continue;
+        }
+        if (!cwd && line.startsWith('cwd: ')) {
+            cwd = line.slice(5).trim();
+            continue;
+        }
+        if (line === '[stderr]') {
+            inStderr = true;
+            continue;
+        }
+        if (!error && line.startsWith('[error]')) {
+            error = line.replace(/^\[error\]\s*/i, '').trim();
+            continue;
+        }
+        if (!exit && line.startsWith('exit: ')) {
+            exit = line.replace(/^exit:\s*/i, 'exit ').trim();
+            continue;
+        }
+        if (inStderr) {
+            stderrLines.push(line);
+        }
+        else {
+            stdoutLines.push(line);
+        }
+    }
+    const stdout = stdoutLines.join('\n').trim();
+    const stderr = stderrLines.join('\n').trim();
+    return {
+        command,
+        cwd,
+        stdout,
+        stderr,
+        error,
+        exit,
+        outputLineCount: stdout ? stdout.split(/\r?\n/).length : 0,
+    };
+}
+export function formatToolDuration(durationMs) {
+    if (typeof durationMs !== 'number' || Number.isNaN(durationMs))
+        return null;
+    if (durationMs < 1000)
+        return null;
+    return `${(durationMs / 1000).toFixed(durationMs >= 10_000 ? 0 : 1)}s`;
+}
+export function countTextLines(value) {
+    if (!value)
+        return 0;
+    return value.split(/\r?\n/).length;
+}
+export function deriveEditorDiffStats(diff) {
+    // Older persisted diff payloads counted empty original content as one removed
+    // line because ''.split('\n') returns ['']. Normalize display stats so a new
+    // file reads as +N -0 and the inline preview matches the counters.
+    if (diff.originalContent.length === 0) {
+        return {
+            added: countNormalizedTextLines(diff.modifiedContent),
+            removed: 0,
+        };
+    }
+    if (diff.modifiedContent.length === 0) {
+        return {
+            added: 0,
+            removed: countNormalizedTextLines(diff.originalContent),
+        };
+    }
+    return {
+        added: diff.addedLines,
+        removed: diff.removedLines,
+    };
+}
+export function parseReplacementCount(result) {
+    const match = result?.match(/Replaced\s+(\d+)\s+occurrence/i);
+    const count = match ? Number.parseInt(match[1], 10) : 1;
+    return Number.isFinite(count) && count > 0 ? count : 1;
+}
+export function deriveToolDiffStats(toolCall) {
+    if (toolCall.status !== 'done' || toolCall.success === false) {
+        return null;
+    }
+    if (toolCall.diff) {
+        return deriveEditorDiffStats(toolCall.diff);
+    }
+    const toolName = toolCall.toolName.toLowerCase();
+    const params = toolCall.params || {};
+    if (toolName === 'edit' || toolName === 'edit_file') {
+        const oldString = typeof params.old_string === 'string' ? params.old_string : '';
+        const newString = typeof params.new_string === 'string' ? params.new_string : '';
+        if (!oldString && !newString)
+            return null;
+        const replacements = parseReplacementCount(toolCall.result);
+        return {
+            added: countTextLines(newString) * replacements,
+            removed: countTextLines(oldString) * replacements
+        };
+    }
+    if (toolName === 'write' || toolName === 'write_file') {
+        const content = typeof params.content === 'string' ? params.content : '';
+        if (!content)
+            return null;
+        return {
+            added: countTextLines(content),
+            removed: 0
+        };
+    }
+    return null;
+}
+export function deriveToolCallFileName(toolCall) {
+    const filePath = deriveToolCallFilePath(toolCall);
+    if (filePath) {
+        const normalized = filePath.replace(/[\\/]+$/, '');
+        const parts = normalized.split(/[/\\]/).filter(Boolean);
+        if (parts.length > 0)
+            return parts[parts.length - 1];
+    }
+    if (toolCall.diff?.name)
+        return toolCall.diff.name;
+    return 'file';
+}
+export function deriveFileToolPrimaryText(toolCall) {
+    const toolName = toolCall.toolName.toLowerCase();
+    if (!['write', 'write_file', 'edit', 'edit_file', 'read', 'read_file'].includes(toolName)) {
+        return null;
+    }
+    if (toolCall.status === 'running') {
+        return null;
+    }
+    if (toolCall.success === false) {
+        return null;
+    }
+    if (toolName === 'read' || toolName === 'read_file') {
+        return 'Read file';
+    }
+    if (toolName === 'edit' || toolName === 'edit_file') {
+        return 'Edited file';
+    }
+    if (toolCall.diff) {
+        const original = toolCall.diff.originalContent || '';
+        const { removed } = deriveEditorDiffStats(toolCall.diff);
+        if (!original.trim() && removed === 0) {
+            return 'Created file';
+        }
+        return 'Edited file';
+    }
+    return 'Created file';
+}
+export function deriveFileToolActionLabel(toolCall) {
+    const toolName = toolCall.toolName.toLowerCase();
+    if (toolName === 'writefiles')
+        return 'Write';
+    if (toolName === 'write' || toolName === 'write_file')
+        return 'Write';
+    if (toolName === 'edit' || toolName === 'edit_file')
+        return 'Edit';
+    if (toolName === 'read' || toolName === 'read_file')
+        return 'Read';
+    return null;
+}
+export function splitPreviewLines(value) {
+    if (!value)
+        return [];
+    return value.replace(/\r\n/g, '\n').replace(/\r/g, '\n').split('\n');
+}
+export function buildInlineDiffPreviewLines(diff, maxChangedLines = 12) {
+    const originalLines = splitPreviewLines(diff.originalContent);
+    const modifiedLines = splitPreviewLines(diff.modifiedContent);
+    if (originalLines.length === 0 && modifiedLines.length === 0) {
+        return [];
+    }
+    let prefix = 0;
+    while (prefix < originalLines.length &&
+        prefix < modifiedLines.length &&
+        originalLines[prefix] === modifiedLines[prefix]) {
+        prefix += 1;
+    }
+    let suffix = 0;
+    while (suffix < originalLines.length - prefix &&
+        suffix < modifiedLines.length - prefix &&
+        originalLines[originalLines.length - 1 - suffix] === modifiedLines[modifiedLines.length - 1 - suffix]) {
+        suffix += 1;
+    }
+    const originalChanged = originalLines.slice(prefix, originalLines.length - suffix);
+    const modifiedChanged = modifiedLines.slice(prefix, modifiedLines.length - suffix);
+    const contextBeforeStart = Math.max(0, prefix - 2);
+    const contextBefore = originalLines.slice(contextBeforeStart, prefix);
+    const contextAfterStart = modifiedLines.length - suffix;
+    const contextAfter = modifiedLines.slice(contextAfterStart, Math.min(modifiedLines.length, contextAfterStart + 2));
+    const lines = [];
+    for (let index = 0; index < contextBefore.length; index += 1) {
+        const oldLineNumber = contextBeforeStart + index + 1;
+        lines.push({
+            kind: 'context',
+            oldLineNumber,
+            newLineNumber: oldLineNumber,
+            text: contextBefore[index],
+        });
+    }
+    const changedLineCount = originalChanged.length + modifiedChanged.length;
+    const truncateChanged = changedLineCount > maxChangedLines;
+    const allowedChangedLines = truncateChanged
+        ? Math.max(2, Math.floor(maxChangedLines / 2))
+        : Number.MAX_SAFE_INTEGER;
+    const removedToShow = truncateChanged ? originalChanged.slice(0, allowedChangedLines) : originalChanged;
+    const addedToShow = truncateChanged ? modifiedChanged.slice(0, allowedChangedLines) : modifiedChanged;
+    for (let index = 0; index < removedToShow.length; index += 1) {
+        lines.push({
+            kind: 'removed',
+            oldLineNumber: prefix + index + 1,
+            text: removedToShow[index],
+        });
+    }
+    for (let index = 0; index < addedToShow.length; index += 1) {
+        lines.push({
+            kind: 'added',
+            newLineNumber: prefix + index + 1,
+            text: addedToShow[index],
+        });
+    }
+    if (truncateChanged) {
+        lines.push({
+            kind: 'ellipsis',
+            text: `... ${changedLineCount - (removedToShow.length + addedToShow.length)} more changed lines`
+        });
+    }
+    for (let index = 0; index < contextAfter.length; index += 1) {
+        const newLineNumber = contextAfterStart + index + 1;
+        lines.push({
+            kind: 'context',
+            oldLineNumber: newLineNumber,
+            newLineNumber,
+            text: contextAfter[index],
+        });
+    }
+    if (lines.length === 0) {
+        const fallbackLines = modifiedLines.length > 0 ? modifiedLines : originalLines;
+        return fallbackLines.slice(0, 6).map((line, index) => ({
+            kind: 'context',
+            oldLineNumber: index + 1,
+            newLineNumber: index + 1,
+            text: line,
+        }));
+    }
+    return lines;
+}
+export function mapWorkspaceChoice(value) {
+    switch (value) {
+        case 'inbox':
+            return 'Keep in Inbox';
+        case 'reuse':
+            return 'Move to existing workspace';
+        case 'create':
+            return 'Create new workspace';
+        default:
+            return value;
+    }
+}
+export function deriveTerminalToolOutput(toolCall) {
+    const toolName = toolCall.toolName.toLowerCase();
+    if (toolName !== 'terminalwriteinput' && toolName !== 'terminalreadoutput')
+        return null;
+    const raw = (toolCall.result || '').trim();
+    if (!raw)
+        return null;
+    try {
+        const parsed = JSON.parse(raw);
+        const output = typeof parsed.output === 'string' ? parsed.output : '';
+        if (!output.trim())
+            return null;
+        return {
+            output,
+            terminalId: typeof parsed.terminalId === 'string' ? parsed.terminalId : undefined,
+            cwd: typeof parsed.cwd === 'string' ? parsed.cwd : undefined,
+        };
+    }
+    catch {
+        if (/^Wrote \d+ characters to terminal/i.test(raw))
+            return null;
+        return { output: raw };
+    }
+}
+export function readToolStringParam(params, keys) {
+    if (!params)
+        return '';
+    for (const key of keys) {
+        const value = params[key];
+        if (typeof value === 'string' && value.trim())
+            return value.trim();
+    }
+    return '';
+}
+export function isPseudoPermissionDirectory(directory) {
+    return /^__.*__$/.test((directory || '').trim());
+}
+export function tokenizeShellCommand(command) {
+    return (command.match(/"[^"]*"|'[^']*'|[^\s]+/g) || [])
+        .map((token) => token.replace(/^["']|["']$/g, '').trim())
+        .filter(Boolean);
+}
+export function deriveShellCommandNames(command) {
+    const tokens = tokenizeShellCommand(command);
+    const commands = [];
+    let expectCommand = true;
+    for (const token of tokens) {
+        const normalized = token.toLowerCase();
+        if (['&&', '||', '|', ';'].includes(normalized)) {
+            expectCommand = true;
+            continue;
+        }
+        if (!expectCommand)
+            continue;
+        if (/^[a-zA-Z][\w.-]*$/.test(token)) {
+            commands.push(token);
+            expectCommand = false;
+        }
+    }
+    return Array.from(new Set(commands));
+}
+export function deriveApprovalCardInfo(toolCall, pr) {
+    const params = toolCall.params || {};
+    const normalizedToolName = toolCall.toolName.toLowerCase();
+    const command = readToolStringParam(params, ['command']);
+    const terminalInput = readToolStringParam(params, ['data']);
+    const browserUrl = readToolStringParam(params, ['url']);
+    const browserSelector = readToolStringParam(params, ['selector']);
+    const browserText = readToolStringParam(params, ['text']);
+    const browserKey = readToolStringParam(params, ['key']);
+    const permissionText = (pr.path || pr.directory || '').trim();
+    const body = (() => {
+        if (command)
+            return command;
+        if (terminalInput)
+            return terminalInput.replace(/\r/g, '\\r').replace(/\n/g, '\\n');
+        if (browserUrl)
+            return browserUrl;
+        if (browserSelector && browserText)
+            return `${browserSelector}\n${browserText}`;
+        if (browserSelector)
+            return browserSelector;
+        if (browserKey)
+            return browserKey;
+        return permissionText || humanizeToolName(toolCall.toolName);
+    })();
+    const description = (() => {
+        if (permissionText)
+            return permissionText;
+        if (normalizedToolName === 'bash')
+            return 'Run shell command';
+        if (normalizedToolName === 'terminalwriteinput')
+            return 'Write to PowerShell terminal';
+        if (normalizedToolName.startsWith('browser'))
+            return humanizeToolName(toolCall.toolName);
+        if (normalizedToolName === 'choosedirectory')
+            return 'Open folder picker';
+        return humanizeToolName(toolCall.toolName);
+    })();
+    const shellNames = deriveShellCommandNames(command || terminalInput);
+    const summary = shellNames.length > 0
+        ? shellNames.slice(0, 3).join(', ')
+        : humanizeToolName(toolCall.toolName);
+    const allowlistLabel = shellNames.length > 0
+        ? `Allowlist '${shellNames[0]}'${shellNames.length > 1 ? ` + ${shellNames.length - 1}` : ''}`
+        : `Allowlist ${humanizeToolName(toolCall.toolName)}`;
+    return {
+        description,
+        summary,
+        body,
+        prompt: normalizedToolName === 'bash' || normalizedToolName === 'terminalwriteinput' ? '$ ' : '',
+        allowlistLabel,
+        runLabel: normalizedToolName === 'choosedirectory' ? 'Open' : 'Run',
+    };
+}
+export function toolCallLabel(toolName, params) {
+    switch (toolName.toLowerCase()) {
+        case 'choosedirectory': {
+            const directory = String(params?.directory || params?.path || '');
+            return directory
+                ? `Selected folder: ${directory}`
+                : 'Selected folder for this conversation';
+        }
+        case 'workspaceselection': {
+            const choice = String(params?.choice || '');
+            return choice ? `Workspace placement: ${choice}` : 'Workspace placement selected';
+        }
+        case 'xenoworkspacemanage': {
+            const action = String(params?.action || 'manage');
+            return `Workspace registry: ${action}`;
+        }
+        case 'bash':
+        case 'run_command': {
+            const cmd = String(params?.command || '');
+            return cmd.length > 60 ? `Running: ${cmd.slice(0, 57)}...` : `Running: ${cmd}`;
+        }
+        case 'runcommand':
+        case 'shell':
+        case 'shell_command':
+        case 'shellcommand':
+        case 'terminal': {
+            const cmd = String(params?.command || '');
+            return cmd ? `Running: ${compactCommandPreview(cmd, 60)}` : 'Terminal command';
+        }
+        case 'websearch':
+        case 'web_search':
+            return `Searching: ${String(params?.query || '')}`;
+        case 'read':
+        case 'read_file':
+            return `Reading: ${String(params?.path || '').split(/[/\\]/).pop() || 'file'}`;
+        case 'write':
+        case 'write_file':
+            return `Writing: ${String(params?.file_path || params?.path || '').split(/[/\\]/).pop() || 'file'}`;
+        case 'edit':
+        case 'edit_file':
+            return `Editing: ${String(params?.file_path || params?.path || '').split(/[/\\]/).pop() || 'file'}`;
+        case 'glob':
+            return `Finding files in ${String(params?.path || '.')}`;
+        case 'grep':
+            return `Searching files for ${String(params?.pattern || params?.query || '')}`;
+        case 'openapp':
+        case 'open_app':
+            return `Opening: ${String(params?.app || params?.appPath || '')}`;
+        default:
+            return `${toolName}(${Object.keys(params || {}).join(', ')})`;
+    }
+}
+export function normalizeTerminalApprovalCommand(raw) {
+    return raw
+        .replace(/\r/g, '\n')
+        .split('\n')
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .join(' && ');
+}
+export function safeUrlOrigin(raw) {
+    try {
+        const url = new URL(raw);
+        return url.protocol === 'http:' || url.protocol === 'https:' ? url.origin : '';
+    }
+    catch {
+        return '';
+    }
+}
+export function buildSurfaceApprovalRule(toolCall, pr) {
+    const params = toolCall.params || {};
+    const action = toolCall.toolName;
+    if (action === 'TerminalWriteInput') {
+        const command = normalizeTerminalApprovalCommand(readToolStringParam(params, ['data', 'command']));
+        if (!command)
+            return null;
+        const names = deriveShellCommandNames(command);
+        return {
+            surface: 'terminal',
+            action,
+            matcher: command,
+            command,
+            label: names.length > 0 ? names.slice(0, 3).join(', ') : command.slice(0, 80),
+        };
+    }
+    if (action === 'BrowserGoto') {
+        const url = readToolStringParam(params, ['url']);
+        const origin = safeUrlOrigin(url);
+        if (!origin)
+            return null;
+        return {
+            surface: 'browser',
+            action,
+            matcher: origin,
+            browserOrigin: origin,
+            urlPattern: origin,
+            label: origin,
+        };
+    }
+    if (action === 'BrowserClick' || action === 'BrowserType') {
+        const selector = readToolStringParam(params, ['selector']);
+        if (!selector)
+            return null;
+        const browserOrigin = pr.browserOrigin || '';
+        return {
+            surface: 'browser',
+            action,
+            matcher: browserOrigin ? `${browserOrigin} ${selector}` : selector,
+            browserOrigin: browserOrigin || undefined,
+            selector,
+            label: browserOrigin ? `${humanizeToolName(toolCall.toolName)} ${browserOrigin}` : `${humanizeToolName(toolCall.toolName)} ${selector}`,
+        };
+    }
+    if (action === 'BrowserKey') {
+        const key = readToolStringParam(params, ['key']);
+        if (!key)
+            return null;
+        const browserOrigin = pr.browserOrigin || '';
+        return {
+            surface: 'browser',
+            action,
+            matcher: browserOrigin ? `${browserOrigin} ${key}` : key,
+            browserOrigin: browserOrigin || undefined,
+            key,
+            label: browserOrigin ? `Browser key ${key} on ${browserOrigin}` : `Browser key ${key}`,
+        };
+    }
+    if (!pr.directory || isPseudoPermissionDirectory(pr.directory))
+        return null;
+    return null;
+}
+export function canBuildSurfaceApprovalRule(toolCall, pr) {
+    return !!buildSurfaceApprovalRule(toolCall, pr);
+}
+//# sourceMappingURL=toolCallDerive.js.map