@semalt-ai/code 1.6.0 → 1.8.0

package/lib/ui/diff.js

@@ -0,0 +1,243 @@
+'use strict';
+
+const { FG_DARK, FG_RED, FG_GREEN, FG_GRAY, FG_YELLOW, FG_TEAL, RST, THEME } = require('./ansi');
+const { getCols, stripAnsi } = require('./utils');
+
+function diffLines(oldLines, newLines) {
+  const m = oldLines.length, n = newLines.length;
+  const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+  for (let i = 1; i <= m; i++)
+    for (let j = 1; j <= n; j++)
+      dp[i][j] = oldLines[i-1] === newLines[j-1] ? dp[i-1][j-1] + 1 : Math.max(dp[i-1][j], dp[i][j-1]);
+  const result = [];
+  let i = m, j = n;
+  while (i > 0 || j > 0) {
+    if (i > 0 && j > 0 && oldLines[i-1] === newLines[j-1]) { result.unshift({ type:'same', text: oldLines[i-1] }); i--; j--; }
+    else if (j > 0 && (i === 0 || dp[i][j-1] >= dp[i-1][j])) { result.unshift({ type:'add', text: newLines[j-1] }); j--; }
+    else { result.unshift({ type:'del', text: oldLines[i-1] }); i--; }
+  }
+  return result;
+}
+
+function diffLinesHashed(oldLines, newLines) {
+  const hashLine = (s) => { let h = 5381; for (let k = 0; k < s.length; k++) h = ((h << 5) + h + s.charCodeAt(k)) | 0; return h; };
+  const oldH = oldLines.map(hashLine), newH = newLines.map(hashLine);
+  const m = oldH.length, n = newH.length;
+  const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+  for (let i = 1; i <= m; i++)
+    for (let j = 1; j <= n; j++)
+      dp[i][j] = oldH[i-1] === newH[j-1] ? dp[i-1][j-1] + 1 : Math.max(dp[i-1][j], dp[i][j-1]);
+  const result = [];
+  let i = m, j = n;
+  while (i > 0 || j > 0) {
+    if (i > 0 && j > 0 && oldH[i-1] === newH[j-1]) { result.unshift({ type:'same', text: oldLines[i-1] }); i--; j--; }
+    else if (j > 0 && (i === 0 || dp[i][j-1] >= dp[i-1][j])) { result.unshift({ type:'add', text: newLines[j-1] }); j--; }
+    else { result.unshift({ type:'del', text: oldLines[i-1] }); i--; }
+  }
+  return result;
+}
+
+function renderDiff(oldText, newText, filePath) {
+  if (oldText.includes('\x00') || newText.includes('\x00')) return '[binary file — diff skipped]';
+  const isTTY = process.stdout.isTTY === true;
+  const cols  = getCols();
+
+  // ── Layout constants ───────────────────────────────────────────────────────
+  const INDENT     = '   ';          // left offset from main stream
+  const boxWidth   = Math.max(40, cols - INDENT.length);
+  const innerWidth = boxWidth - 2;   // between ╭ and ╮
+
+  const a  = (code) => isTTY ? code : '';
+  const R  = a(RST);
+
+  // Palette
+  const BORDER   = a(FG_DARK);
+  const DEL_BG   = a('\x1b[48;5;52m');    // dark red background
+  const ADD_BG   = a('\x1b[48;5;22m');    // dark green background
+  const DEL_FG   = a('\x1b[38;5;203m');   // bright red text  (= FG_RED)
+  const ADD_FG   = a('\x1b[38;5;114m');   // bright green text (= FG_GREEN)
+  const NUM_CLR  = a('\x1b[38;5;240m');   // muted line-number gutter
+  const CTX_CLR  = a('\x1b[38;5;245m');   // dim context text
+  const HUNK_CLR = a('\x1b[38;5;73m');    // teal hunk separator
+  const PATH_CLR = a('\x1b[38;5;222m');   // yellow filepath in header
+
+  const oldLines  = oldText === '' ? [] : oldText.split('\n');
+  const newLines  = newText.split('\n');
+  const isNewFile = oldText === '';
+
+  let diff;
+  if (!isNewFile) {
+    diff = (oldLines.length > 200 || newLines.length > 200)
+      ? diffLinesHashed(oldLines, newLines) : diffLines(oldLines, newLines);
+    if (!diff.some((d) => d.type !== 'same')) return `${INDENT}  No changes detected`;
+  }
+
+  // Gutter width: enough digits for the largest line number
+  const maxLn = Math.max(oldLines.length, newLines.length, 1);
+  const LN_W  = Math.max(2, String(maxLn).length);
+
+  // gutter template: ' NNNN │S ' — LN_W + 5 chars
+  const GUTTER_W = LN_W + 5;
+  const CONT_W   = Math.max(1, innerWidth - GUTTER_W);
+
+  // ── Builders ───────────────────────────────────────────────────────────────
+
+  // One content line inside the box.
+  //   lnStr  – line-number string (right-aligned to LN_W, or '' for unknown)
+  //   symbol – '-', '+', or ' '
+  //   text   – raw source text
+  //   bg     – background ANSI string (or '' for context)
+  //   fg     – foreground ANSI string
+  function makeLine(lnStr, symbol, text, bg, fg) {
+    const num    = lnStr ? lnStr.padStart(LN_W) : ' '.repeat(LN_W);
+    const disp   = text.replace(/\t/g, '  ');
+    const clp    = disp.length > CONT_W ? disp.slice(0, CONT_W - 1) + '…' : disp;
+    const padded = clp.padEnd(CONT_W);
+    // gutter:  ' NUM │S '
+    const gt = ` ${NUM_CLR}${num}${R}${bg}${BORDER} │${R}${bg}${fg}${symbol} ${padded}${R}`;
+    return `${INDENT}${BORDER}│${R}${bg}${gt}${R}${BORDER}│${R}`;
+  }
+
+  // Hunk separator: ···· @@ -x,y +a,b @@ ····
+  function hunkSep(label) {
+    const body  = ` ${label} `;
+    const total = innerWidth - 2;  // 2 for leading/trailing ·
+    const half  = Math.max(0, Math.floor((total - body.length) / 2));
+    const right = Math.max(0, total - body.length - half);
+    return `${INDENT}${BORDER}│${R}${HUNK_CLR} ${'·'.repeat(half)}${body}${'·'.repeat(right)} ${R}${BORDER}│${R}`;
+  }
+
+  const out = [];
+
+  // ── Header ─────────────────────────────────────────────────────────────────
+  const pathPart  = ` ${filePath} `;
+  const fillRight = Math.max(1, innerWidth - 1 - pathPart.length);  // 1 for leading ─
+  out.push(`${INDENT}${BORDER}╭─${PATH_CLR}${pathPart}${R}${BORDER}${'─'.repeat(fillRight)}╮${R}`);
+
+  // ── Body ───────────────────────────────────────────────────────────────────
+  if (isNewFile) {
+    out.push(hunkSep('new file'));
+    let ln = 1;
+    for (const line of newLines) {
+      out.push(makeLine(String(ln++), '+', line, ADD_BG, ADD_FG));
+    }
+  } else {
+    let oldLn = 1, newLn = 1;
+    const annotated = diff.map((d) => {
+      const e = { type: d.type, text: d.text, oldLine: null, newLine: null };
+      if (d.type !== 'add') e.oldLine = oldLn++;
+      if (d.type !== 'del') e.newLine = newLn++;
+      return e;
+    });
+
+    const changedIdx = [];
+    annotated.forEach((d, i) => { if (d.type !== 'same') changedIdx.push(i); });
+
+    const CONTEXT = 3;
+    const ranges = [];
+    let rS = Math.max(0, changedIdx[0] - CONTEXT);
+    let rE = Math.min(annotated.length - 1, changedIdx[0] + CONTEXT);
+    for (let k = 1; k < changedIdx.length; k++) {
+      const ci = changedIdx[k];
+      if (ci - CONTEXT <= rE + 1) { rE = Math.min(annotated.length - 1, ci + CONTEXT); }
+      else { ranges.push([rS, rE]); rS = Math.max(0, ci - CONTEXT); rE = Math.min(annotated.length - 1, ci + CONTEXT); }
+    }
+    ranges.push([rS, rE]);
+
+    for (const [hS, hE] of ranges) {
+      const hunk     = annotated.slice(hS, hE + 1);
+      const oldStart = hunk.find((e) => e.oldLine !== null)?.oldLine ?? 0;
+      const newStart = hunk.find((e) => e.newLine !== null)?.newLine ?? 0;
+      const oldCnt   = hunk.filter((e) => e.oldLine !== null).length;
+      const newCnt   = hunk.filter((e) => e.newLine !== null).length;
+      out.push(hunkSep(`@@ -${oldStart},${oldCnt} +${newStart},${newCnt} @@`));
+
+      for (const e of hunk) {
+        if (e.type === 'del') {
+          out.push(makeLine(String(e.oldLine), '-', e.text, DEL_BG, DEL_FG));
+        } else if (e.type === 'add') {
+          out.push(makeLine(String(e.newLine), '+', e.text, ADD_BG, ADD_FG));
+        } else {
+          out.push(makeLine(String(e.newLine), ' ', e.text, '', CTX_CLR));
+        }
+      }
+    }
+  }
+
+  // ── Footer ─────────────────────────────────────────────────────────────────
+  out.push(`${INDENT}${BORDER}╰${'─'.repeat(innerWidth)}╯${R}`);
+
+  const MAX = 120;
+  if (out.length > MAX) {
+    const extra  = out.length - MAX;
+    const result = out.slice(0, MAX);
+    result.push(isTTY
+      ? `${INDENT}${FG_DARK}  … ${extra} more lines${RST}`
+      : `… ${extra} more lines`);
+    return result.join('\n');
+  }
+  return out.join('\n');
+}
+
+function _mdInline(text) {
+  let out = '', i = 0;
+  while (i < text.length) {
+    const c = text[i], c1 = i + 1 < text.length ? text[i+1] : '';
+    if (c === '`') { const end = text.indexOf('`', i+1); if (end !== -1) { out += '\x1b[7m' + text.slice(i+1, end) + '\x1b[27m'; i = end+1; continue; } }
+    if (c === '*' && c1 === '*') { const end = text.indexOf('**', i+2); if (end !== -1) { out += '\x1b[1m' + text.slice(i+2, end) + '\x1b[22m'; i = end+2; continue; } }
+    if (c === '_' && c1 === '_') { const end = text.indexOf('__', i+2); if (end !== -1) { out += '\x1b[1m' + text.slice(i+2, end) + '\x1b[22m'; i = end+2; continue; } }
+    if (c === '*' && c1 !== '*') { let end = -1; for (let j = i+1; j < text.length; j++) { if (text[j] === '*' && (j+1 >= text.length || text[j+1] !== '*')) { end = j; break; } } if (end !== -1) { out += '\x1b[3m' + text.slice(i+1, end) + '\x1b[23m'; i = end+1; continue; } }
+    if (c === '_' && c1 !== '_') { let end = -1; for (let j = i+1; j < text.length; j++) { if (text[j] === '_' && (j+1 >= text.length || text[j+1] !== '_')) { end = j; break; } } if (end !== -1) { out += '\x1b[3m' + text.slice(i+1, end) + '\x1b[23m'; i = end+1; continue; } }
+    out += text[i++];
+  }
+  return out;
+}
+
+function renderMarkdown(text) {
+  if (!process.stdout.isTTY) { process.stdout.write(text); return; }
+  const { loadConfig } = require('../config');
+  const maxLines = (loadConfig().max_output_lines) || 50;
+  const cols = getCols();
+  const srcLines = text.split('\n');
+  const output = [];
+  let inCode = false;
+  for (let li = 0; li < srcLines.length; li++) {
+    const line = srcLines[li];
+    if (!inCode && line.length >= 3 && line[0] === '`' && line[1] === '`' && line[2] === '`') {
+      const lang = line.slice(3).trim();
+      const label = lang ? (' ' + lang + ' ') : '';
+      output.push('┌─── ' + label + '─'.repeat(Math.max(1, cols - 5 - label.length)));
+      inCode = true; continue;
+    }
+    if (inCode) {
+      const t = line.trim();
+      if (t.length === 3 && t[0] === '`' && t[1] === '`' && t[2] === '`') { output.push('└' + '─'.repeat(Math.max(1, cols - 2))); inCode = false; }
+      else { output.push('│  ' + THEME.dim + line + THEME.reset); }
+      continue;
+    }
+    const trimmed = line.trim();
+    if (trimmed === '---' || trimmed === '===') { output.push(THEME.dim + '─'.repeat(cols) + THEME.reset); continue; }
+    let level = 0;
+    while (level < line.length && line[level] === '#') level++;
+    if (level >= 1 && level <= 3 && level < line.length && line[level] === ' ') {
+      const htext = line.slice(level + 1);
+      if (level === 1) { output.push(THEME.agent + '\x1b[1m' + htext + THEME.reset); output.push(THEME.dim + '═'.repeat(cols) + THEME.reset); }
+      else if (level === 2) { output.push('\x1b[1m' + htext + '\x1b[0m'); output.push(THEME.dim + '─'.repeat(cols) + THEME.reset); }
+      else { output.push('\x1b[1m' + htext + '\x1b[0m'); }
+      continue;
+    }
+    if (line.length > 0 && line[0] === '>') { const inner = line.length > 1 && line[1] === ' ' ? line.slice(2) : line.slice(1); output.push(THEME.tool + '│' + THEME.reset + ' ' + _mdInline(inner)); continue; }
+    let indent = 0; while (indent < line.length && line[indent] === ' ') indent++;
+    const rest = line.slice(indent);
+    if (rest.length > 2 && (rest[0] === '-' || rest[0] === '*') && rest[1] === ' ') { output.push('  '.repeat(Math.floor(indent/2)) + THEME.agent + '❯' + THEME.reset + ' ' + _mdInline(rest.slice(2))); continue; }
+    let ni = 0; while (ni < line.length && line[ni] >= '0' && line[ni] <= '9') ni++;
+    if (ni > 0 && ni < line.length - 1 && line[ni] === '.' && line[ni+1] === ' ') { output.push(THEME.dim + line.slice(0, ni) + '.' + THEME.reset + ' ' + _mdInline(line.slice(ni+2))); continue; }
+    output.push(_mdInline(line));
+  }
+  let overflow = 0, printLines = output;
+  if (output.length > maxLines) { overflow = output.length - maxLines; printLines = output.slice(0, maxLines); }
+  for (const l of printLines) process.stdout.write(l + '\n');
+  if (overflow > 0) process.stdout.write(THEME.dim + '[... ' + overflow + ' more lines]' + THEME.reset + '\n');
+}
+
+module.exports = { renderDiff, renderMarkdown, _mdInline };