@bahulam/code 2.6.13 → 2.6.14

package/src/terminal/tool-display.mjs

@@ -35,6 +35,10 @@ const TOOL_LABELS = Object.freeze({
   workflow_create_multi: 'Creating workflow',
   workflow_sync_multi: 'Syncing workflows',
   workflow_run_multi: 'Running workflow',
+  Agent: 'Delegating',
+  agent: 'Delegating',
+  task: 'Delegating',
+  sub_agent_tools: 'Sub-agent tools',
   explore: 'Exploring',
   plan: 'Planning',
   verify: 'Verifying',
@@ -43,9 +47,15 @@ const TOOL_LABELS = Object.freeze({
   ask_user: 'Asking',
 });
 
+function labelKey(tool) {
+  const raw = String(tool || '');
+  return TOOL_LABELS[raw] ? raw : raw.toLowerCase();
+}
+
 export function toolDisplayLabel(tool) {
   if (!tool) return 'Use tool';
-  if (TOOL_LABELS[tool]) return TOOL_LABELS[tool];
+  const key = labelKey(tool);
+  if (TOOL_LABELS[key]) return TOOL_LABELS[key];
   return tool
     .replace(/^mcp[_-]?/i, '')
     .split(/[_-]+/)
@@ -85,7 +95,8 @@ function firstParagraph(text) {
 }
 
 export function toolDisplaySummary(tool, args = {}, { cwd } = {}) {
-  switch (tool) {
+  const key = String(tool || '').toLowerCase();
+  switch (key) {
     case 'shell':
       return args.command || '(empty command)';
     case 'read_file': {
@@ -159,6 +170,17 @@ export function toolDisplaySummary(tool, args = {}, { cwd } = {}) {
       return args.name || args.slug || 'all local workflows';
     case 'workflow_run_multi':
       return [args.workflow_id || args.workflowId || args.name || '', args.pattern || 'sequential'].filter(Boolean).join(' · ');
+    case 'agent':
+    case 'task': {
+      const agentName = args.subagent_type || args.agent || args.name || args.type || '';
+      const task = firstParagraph(args.prompt || args.task || args.query || args.description || args.instruction || '');
+      return [agentName, task].filter(Boolean).join(' · ');
+    }
+    case 'sub_agent_tools': {
+      const total = Number(args.total || args.count || 0);
+      const agent = args.agent || args.type || '';
+      return [agent, total > 0 ? `${total} tool use${total === 1 ? '' : 's'}` : ''].filter(Boolean).join(' · ');
+    }
     case 'explore':
     case 'plan':
     case 'verify':
@@ -185,6 +207,117 @@ export function shellCommandDisplay(command, { cwd = currentWorkingDirectory() }
   };
 }
 
+const COMPACT_SHELL_CHARS = 320;
+const COMPACT_SHELL_LINES = 2;
+
+export function shellCommandProfile(command, {
+  cwd = currentWorkingDirectory(),
+  compactChars = COMPACT_SHELL_CHARS,
+  compactLines = COMPACT_SHELL_LINES,
+} = {}) {
+  const original = String(command || '');
+  const display = shellCommandDisplay(original, { cwd });
+  const normalized = String(display.command || '').replace(/\r\n?/g, '\n');
+  const body = normalized || '(empty command)';
+  const lines = normalized ? normalized.split('\n') : [];
+  const commandLineCount = Math.max(1, lines.filter(line => line.trim()).length || lines.length);
+  const commandByteCount = byteLength(normalized || body);
+  const script = detectShellScript(normalized);
+  const lineCount = script?.body ? physicalLineCount(script.body) : commandLineCount;
+  const byteCount = script?.body ? byteLength(script.body) : commandByteCount;
+  const compact = Boolean(script)
+    || commandLineCount >= compactLines
+    || commandByteCount > compactChars;
+  const kind = script?.kind || (lineCount > 1 ? 'shell script' : 'shell command');
+  const summary = compact
+    ? `${kind} · ${lineCount} line${lineCount === 1 ? '' : 's'} · ${formatBytes(byteCount)}`
+    : body;
+
+  return {
+    original,
+    command: body,
+    cwdLabel: display.cwdLabel,
+    lineCount,
+    byteCount,
+    commandLineCount,
+    commandByteCount,
+    compact,
+    kind,
+    summary,
+    script,
+    detailHint: compact ? 'details: F2 or /last' : '',
+  };
+}
+
+function detectShellScript(command) {
+  const text = String(command || '').replace(/\r\n?/g, '\n');
+  if (!text) return null;
+
+  const heredoc = text.match(/\b(python3?|node|ruby|perl|bash|sh)\b[^\n]*<<-?\s*(['"]?)([A-Za-z_][A-Za-z0-9_]*)\2[^\n]*\n([\s\S]*?)\n\3(?:\s*$|\s)/);
+  if (heredoc) {
+    const invocation = text.slice(0, text.indexOf('\n')).trim();
+    return {
+      kind: interpreterKind(heredoc[1]),
+      interpreter: heredoc[1],
+      marker: heredoc[3],
+      invocation,
+      body: heredoc[4],
+    };
+  }
+
+  const inline = text.match(/\b(python3?|node|ruby|perl)\b\s+(?:-[A-Za-z]*[ce][A-Za-z]*|--command|--eval)\s+(['"])([\s\S]{120,})\2/);
+  if (inline) {
+    return {
+      kind: interpreterKind(inline[1]),
+      interpreter: inline[1],
+      invocation: text.slice(0, inline.index + inline[0].indexOf(inline[2])).trim(),
+      body: inline[3],
+    };
+  }
+
+  const tempScript = text.match(/\b(python3?|node|ruby|perl|bash|sh)\b\s+((?:\/(?:private\/)?tmp|\/private\/var\/folders|\/var\/folders)[^\s;&|]+\.(?:py|mjs|js|rb|pl|sh))\b/);
+  if (tempScript) {
+    return {
+      kind: interpreterKind(tempScript[1]),
+      interpreter: tempScript[1],
+      invocation: `${tempScript[1]} ${tempScript[2]}`,
+      path: tempScript[2],
+    };
+  }
+
+  return null;
+}
+
+function interpreterKind(value) {
+  const name = String(value || '').toLowerCase();
+  if (name.startsWith('python')) return 'python script';
+  if (name === 'node') return 'node script';
+  if (name === 'ruby') return 'ruby script';
+  if (name === 'perl') return 'perl script';
+  return 'shell script';
+}
+
+function byteLength(value) {
+  try {
+    return Buffer.byteLength(String(value || ''), 'utf8');
+  } catch {
+    return String(value || '').length;
+  }
+}
+
+function physicalLineCount(value) {
+  const text = String(value || '');
+  if (!text) return 0;
+  return text.split('\n').length;
+}
+
+function formatBytes(bytes) {
+  const n = Number(bytes) || 0;
+  if (n < 1024) return `${n} B`;
+  if (n < 1024 * 1024) return `${(n / 1024).toFixed(n < 10 * 1024 ? 1 : 0)} KB`;
+  return `${(n / (1024 * 1024)).toFixed(1)} MB`;
+}
+
 export function formatShellCommand(command, colors) {
   const tokens = String(command || '').match(/"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|&&|\|\||[|;<>]|[^\s]+|\s+/g) || [];
   let expectsCommand = true;

package/src/ui/approval.mjs

@@ -17,7 +17,7 @@
 
 import { paint, width as visibleWidth } from './palette.mjs';
 import { icon } from './icons.mjs';
-import { shellCommandDisplay, toolDisplayLabel, toolDisplaySummary } from '../terminal/tool-display.mjs';
+import { shellCommandDisplay, shellCommandProfile, toolDisplayLabel, toolDisplaySummary } from '../terminal/tool-display.mjs';
 import { label as tierLabel, requiresExplicitApproval, TIERS } from '../core/risk-tier.mjs';
 
 /**
@@ -29,12 +29,19 @@ import { label as tierLabel, requiresExplicitApproval, TIERS } from '../core/ris
  *   value — return value from the menu loop
  *   hint  — secondary description shown to the right of the label
  */
-export function defaultOptions(tier) {
+export function defaultOptions(tier, { tool = '', args = {} } = {}) {
   const approve = { key: 'y', label: 'approve once',  value: 'approve',  hint: 'run this call' };
   const cancel = { key: 'n', label: 'cancel', value: 'reject', hint: 'do not run' };
   if (requiresExplicitApproval(tier)) {
     return [approve, cancel];
   }
+  if (tool === 'shell') {
+    return [
+      approve,
+      { key: 't', label: 'allow similar', value: 'allow-session', hint: `auto-approve ${shellTrustHint(args)} this session` },
+      cancel,
+    ];
+  }
   return [
     approve,
     { key: 't', label: 'always allow',    value: 'allow-type',  hint: 'auto-approve future calls to this tool' },
@@ -65,27 +72,63 @@ export function defaultOptions(tier) {
  */
 export function renderApprovalPrompt({
   tool, args = {}, tier, why = '', width,
-  options, selected = 0,
+  options, selected = 0, showDetails = false,
 } = {}) {
   const cols = Math.max(60, Math.min(width || process.stderr.columns || 96, 120));
   const explicit = requiresExplicitApproval(tier);
   const accent = explicit ? paint.brand.accent : paint.brand.data;
-  const opts = options || defaultOptions(tier);
-  const title = `${approvalTitle(tier).toLowerCase()} · ${tierLabel(tier)} · ${tool || 'tool'}`;
+  const opts = options || defaultOptions(tier, { tool, args });
+  const title = `⚠ ${approvalTitle(tier)} · ${tierLabel(tier)} · ${tool || 'tool'}`;
 
   const lines = [
     blockHeader(title, accent),
     ...subjectRows(tool, args, cols, accent),
+    ...detailRows(tool, args, cols, accent, showDetails),
     ...riskRows(tool, args, tier, accent),
-    ...reasonRows(why, cols, accent),
+    ...reasonRows(tool, args, why, cols, accent),
     blockLine(accent),
     ...decisionRows(opts, selected, accent),
-    blockLine(accent, paint.text.dim('↑↓ move · Enter pick · letter shortcut · Esc cancel')),
+    blockLine(accent, paint.text.dim(approvalFooter(tool, showDetails))),
   ];
 
   return '\n' + lines.join('\n');
 }
 
+export function renderApprovalDockPrompt({
+  tool, args = {}, tier, why = '', width,
+  options, selected = 0, showDetails = false,
+} = {}) {
+  const cols = Math.max(60, Math.min(width || process.stderr.columns || 96, 120));
+  const opts = options || defaultOptions(tier, { tool, args });
+  const subject = approvalDockSubject(tool, args, cols, showDetails);
+  const risks = riskTerms(tool, args, tier);
+  const reason = compactReason(tool, args, why);
+  const lines = [
+    ...approvalDockSubjectRows(subject),
+    ...(risks.length ? [`${paint.text.dim('risk   ')}${paint.state.warn(risks.join(', '))}`] : []),
+    ...(reason ? [`${paint.text.dim('reason ')}${paint.text.primary(truncate(reason, 120))}`] : []),
+    paint.text.dim('Decision'),
+    ...opts.map((option, index) => optionToken(option, index === selected, explicitAccent(tier))),
+  ];
+
+  return {
+    prefix: '? approve › ',
+    value: truncateForDock(subject, showDetails ? 1200 : 220),
+    context: `${approvalTitle(tier)} · ${tierLabel(tier)} · ${tool || 'tool'}`,
+    meta: '',
+    tips: approvalFooter(tool, showDetails),
+    lines,
+    maxRows: showDetails ? 12 : 8,
+  };
+}
+
+function shellTrustHint(args = {}) {
+  const display = shellCommandDisplay(args.command || args.cmd || '');
+  const parts = String(display.command || '').trim().split(/\s+/).filter(Boolean);
+  const shape = parts.slice(0, 2).join(' ');
+  return shape ? `${shape}*` : 'similar shell commands';
+}
+
 export function renderTrustedApproval({ tool, args = {}, scope = 'session', ruleId = '', delaySeconds = 0 } = {}) {
   const summary = approvalSubjectSummary(tool, args);
   const subject = `${tool || 'tool'}${summary ? ` "${truncate(summary, 80)}"` : ''}`;
@@ -138,18 +181,22 @@ function approvalTitle(tier) {
 }
 
 function blockHeader(title, accent) {
-  return `  ${accent('╭─')} ${paint.bold(accent(title))}`;
+  return `  ${paint.bold(accent(title))}`;
 }
 
 function blockLine(accent, text = '') {
-  return `  ${accent('│')}${text ? ` ${text}` : ''}`;
+  return text ? `  ${text}` : '  ';
+}
+
+function explicitAccent(tier) {
+  return requiresExplicitApproval(tier) ? paint.brand.accent : paint.brand.data;
 }
 
 function subjectRows(tool, args, cols, accent) {
   const rows = [];
   const available = Math.max(24, cols - 5);
   const summary = toolDisplaySummary(tool, args, {});
-  const label = `${icon(tool)} ${paint.text.primary(toolDisplayLabel(tool))}`;
+  const label = subjectLabel(tool);
   const details = subjectDetails(tool, args, summary, Math.max(24, available - visibleWidth(label) - 1));
 
   if (details.length === 1 && visibleWidth(`${label} ${details[0]}`) <= available) {
@@ -164,6 +211,14 @@ function subjectRows(tool, args, cols, accent) {
   return rows;
 }
 
+function subjectLabel(tool) {
+  const label = toolDisplayLabel(tool);
+  if (tool === 'shell') {
+    return `${paint.text.dim('• shell ·')} ${paint.text.primary(label)}`;
+  }
+  return `${icon(tool)} ${paint.text.primary(label)}`;
+}
+
 function decisionRows(opts, selected, accent) {
   const rows = [blockLine(accent, paint.text.dim('Decision'))];
   for (let i = 0; i < opts.length; i++) {
@@ -172,8 +227,8 @@ function decisionRows(opts, selected, accent) {
   return rows;
 }
 
-function reasonRows(why, cols, accent) {
-  const reason = String(why || '').replace(/\s+/g, ' ').trim();
+function reasonRows(tool, args, why, cols, accent) {
+  const reason = compactReason(tool, args, why);
   if (!reason) return [];
   const label = paint.text.dim('reason ');
   const firstWidth = Math.max(20, cols - 5 - visibleWidth(label));
@@ -192,6 +247,21 @@ function reasonRows(why, cols, accent) {
   return rows;
 }
 
+function compactReason(tool, args = {}, why = '') {
+  const reason = String(why || '').replace(/\s+/g, ' ').trim();
+  if (!reason || tool !== 'shell') return reason;
+
+  const redundantShellPrefix = reason.match(/^Shell command requires approval:\s*(.+)$/i);
+  if (!redundantShellPrefix) return reason;
+
+  const command = String(args.command || args.cmd || '').replace(/\s+/g, ' ').trim();
+  const repeated = redundantShellPrefix[1].replace(/\s+/g, ' ').trim();
+  if (!command || repeated === command || command.startsWith(repeated) || repeated.startsWith(command)) {
+    return 'Shell command requires approval.';
+  }
+  return reason;
+}
+
 function riskRows(tool, args = {}, tier, accent) {
   const terms = riskTerms(tool, args, tier);
   if (!terms.length) return [];
@@ -230,8 +300,16 @@ function optionToken(option, selected, accent) {
 
 function subjectDetails(tool, args = {}, summary = '', available = 72) {
   if (tool === 'shell') {
-    const display = shellCommandDisplay(args.command || args.cmd || summary || '');
-    const lines = wrapText(display.command, available);
+    const command = args.command || args.cmd || summary || '';
+    const profile = shellCommandProfile(command);
+    if (profile.compact) {
+      const lines = [`$ ${profile.summary}`];
+      if (profile.cwdLabel) lines.push(`in ${profile.cwdLabel}`);
+      return lines;
+    }
+    const display = shellCommandDisplay(command);
+    const lines = wrapText(display.command, Math.max(20, available - 2))
+      .map((line, index) => `${index === 0 ? '$' : '>'} ${line}`);
     if (display.cwdLabel) lines.push(`in ${display.cwdLabel}`);
     return lines.length ? lines : ['(empty command)'];
   }
@@ -259,6 +337,72 @@ function subjectDetails(tool, args = {}, summary = '', available = 72) {
   return wrapText(summary || JSON.stringify(args || {}), available).slice(0, 4);
 }
 
+function detailRows(tool, args = {}, cols, accent, showDetails) {
+  if (!showDetails || tool !== 'shell') return [];
+  const profile = shellCommandProfile(args.command || args.cmd || '');
+  const rows = [];
+  const labelWidth = 9;
+  const textWidth = Math.max(28, cols - 5 - labelWidth);
+
+  if (profile.cwdLabel) {
+    rows.push(blockLine(accent, `${paint.text.dim('cwd    ')} ${paint.brand.data(profile.cwdLabel)}`));
+  }
+
+  rows.push(blockLine(accent, paint.text.dim('details')));
+  if (profile.script?.body) {
+    const invocation = profile.script.invocation || profile.command.split('\n')[0] || profile.command;
+    for (const line of wrapText(invocation, textWidth)) {
+      rows.push(blockLine(accent, `${paint.text.dim('cmd    ')} ${paint.text.primary(line)}`));
+    }
+    rows.push(blockLine(accent, paint.text.dim('script ')));
+    rows.push(...numberedRows(profile.script.body, cols, accent, 120));
+  } else {
+    rows.push(...wrappedLabeledRows('cmd    ', profile.command, cols, accent, 120));
+  }
+
+  return rows;
+}
+
+function approvalFooter(tool, showDetails) {
+  const details = tool === 'shell'
+    ? ` · d ${showDetails ? 'hide details' : 'details'}`
+    : '';
+  return `↑↓ move · Enter pick · letter shortcut${details} · Esc cancel`;
+}
+
+function approvalDockDetails(tool, args = {}, cols = 96) {
+  if (tool !== 'shell') return subjectDetails(tool, args, toolDisplaySummary(tool, args, {}), cols).join(' · ');
+  const profile = shellCommandProfile(args.command || args.cmd || '');
+  if (profile.script?.body) {
+    const invocation = profile.script.invocation || profile.command.split('\n')[0] || profile.command;
+    return [
+      `$ ${invocation}`,
+      ...profile.script.body.split(/\r?\n/).slice(0, 12).map((line, index) => `${index + 1} ${line}`),
+      ...(profile.script.body.split(/\r?\n/).length > 12 ? ['...'] : []),
+    ].join('\n');
+  }
+  return profile.command;
+}
+
+function approvalDockSubject(tool, args = {}, cols = 96, showDetails = false) {
+  if (showDetails && tool === 'shell') return approvalDockDetails(tool, args, cols);
+  return subjectDetails(
+    tool,
+    args,
+    toolDisplaySummary(tool, args, {}),
+    Math.max(24, cols - 20),
+  ).join(' · ');
+}
+
+function approvalDockSubjectRows(subject) {
+  const lines = String(subject || '').split('\n');
+  const first = lines.shift() || '';
+  return [
+    `${paint.text.dim('? approve ›')} ${paint.text.primary(truncate(first, 160))}`,
+    ...lines.slice(0, 6).map(line => `${paint.text.dim('           ')}${paint.text.primary(truncate(line, 160))}`),
+  ];
+}
+
 function approvalSubjectSummary(tool, args = {}) {
   const summary = toolDisplaySummary(tool, args, {});
   if (tool !== 'shell') return summary;
@@ -274,6 +418,48 @@ function hostFromUrl(url) {
   }
 }
 
+function wrappedLabeledRows(label, text, cols, accent, maxLines = 120) {
+  const rows = [];
+  const labelText = paint.text.dim(label);
+  const firstWidth = Math.max(28, cols - 5 - visibleWidth(labelText) - 1);
+  const restWidth = Math.max(28, cols - 5 - visibleWidth(labelText) - 1);
+  const sourceLines = String(text || '').replace(/\r\n?/g, '\n').split('\n');
+  let emitted = 0;
+  for (const source of sourceLines) {
+    const wrapped = wrapText(source || ' ', emitted === 0 ? firstWidth : restWidth);
+    for (const line of wrapped) {
+      if (emitted >= maxLines) {
+        rows.push(blockLine(accent, `${paint.text.dim('       ')}${paint.text.dim('... detail truncated')}`));
+        return rows;
+      }
+      rows.push(blockLine(accent, `${emitted === 0 ? labelText : paint.text.dim('       ')} ${paint.text.primary(line)}`));
+      emitted++;
+    }
+  }
+  return rows;
+}
+
+function numberedRows(text, cols, accent, maxLines = 120) {
+  const rows = [];
+  const lines = String(text || '').replace(/\r\n?/g, '\n').split('\n');
+  const width = String(Math.min(lines.length, maxLines)).length;
+  const textWidth = Math.max(28, cols - 5 - width - 2);
+  for (let i = 0; i < Math.min(lines.length, maxLines); i++) {
+    const n = String(i + 1).padStart(width);
+    rows.push(blockLine(accent, `${paint.text.dim(`${n} `)}${paint.text.primary(truncate(lines[i], textWidth))}`));
+  }
+  if (lines.length > maxLines) {
+    rows.push(blockLine(accent, `${paint.text.dim(`... ${lines.length - maxLines} more line(s)`)}`));
+  }
+  return rows;
+}
+
+function truncateForDock(text, maxChars) {
+  const value = String(text || '').trim();
+  if (value.length <= maxChars) return value;
+  return `${value.slice(0, Math.max(0, maxChars - 1))}…`;
+}
+
 function wrapText(text, width) {
   const words = String(text || '').split(/\s+/).filter(Boolean);
   if (!words.length) return [''];

package/src/ui/icons.mjs

@@ -61,6 +61,10 @@ const TOOL_ICON = Object.freeze({
   verify:            'subAgent',
   debug:             'subAgent',
   refactor:          'subAgent',
+  Agent:             'subAgent',
+  agent:             'subAgent',
+  task:              'subAgent',
+  sub_agent_tools:   'subAgent',
 
   // Read / search
   read_file:         'search',
@@ -133,14 +137,15 @@ export const icons = new Proxy({}, {
  */
 export function icon(toolName) {
   if (!toolName) return '';
-  const key = TOOL_ICON[toolName];
+  const raw = String(toolName);
+  const key = TOOL_ICON[raw] || TOOL_ICON[raw.toLowerCase()];
   if (key) return render(ICON_RECORDS[key]);
 
   // MCP tools often arrive as "mcp__server__tool" — strip the prefix and
   // try again before falling back to the generic glyph.
-  if (toolName.startsWith('mcp')) {
-    const cleaned = toolName.replace(/^mcp[_-]+/, '').split(/[_-]+/)[0];
-    const fallback = TOOL_ICON[cleaned];
+  if (raw.startsWith('mcp')) {
+    const cleaned = raw.replace(/^mcp[_-]+/, '').split(/[_-]+/)[0];
+    const fallback = TOOL_ICON[cleaned] || TOOL_ICON[cleaned.toLowerCase()];
     if (fallback) return render(ICON_RECORDS[fallback]);
   }
 
@@ -152,7 +157,8 @@ export function icon(toolName) {
  * Used by tier classification and color choice in the tool card renderer.
  */
 export function toolFamily(toolName) {
-  return TOOL_ICON[toolName] || 'other';
+  const raw = String(toolName || '');
+  return TOOL_ICON[raw] || TOOL_ICON[raw.toLowerCase()] || 'other';
 }
 
 /**