@golba98/codexa 1.0.1

package/src/ui/terminalAnswerFormat.ts

@@ -0,0 +1,128 @@
+const MARKDOWN_LINK_RE = /!?\[([^\]\n]+)\]\(([^)\n]+)\)/g;
+const FILE_URL_RE = /\bfile:\/\/\/?[^\s`"'<>)]*/gi;
+const WINDOWS_ABSOLUTE_PATH_RE = /\b[A-Za-z]:[\\/][^\n`"'<>)]*?\.(?:tsx?|jsx?|md|json|ya?ml|toml|css|html|py|txt|mjs|cjs)(?:#L\d+(?:-L?\d+)?)?/g;
+const UNIX_ABSOLUTE_PATH_RE = /(?:^|[\s(])((?:\/Users|\/home|\/workspace|\/workspaces|\/mnt\/[a-z])\/[^\n`"'<>)]*?\.(?:tsx?|jsx?|md|json|ya?ml|toml|css|html|py|txt|mjs|cjs)(?:#L\d+(?:-L?\d+)?)?)/g;
+
+const PATH_ROOT_SEGMENTS = new Set([
+  ".github",
+  "app",
+  "bin",
+  "components",
+  "docs",
+  "lib",
+  "pages",
+  "preview",
+  "scripts",
+  "src",
+  "test",
+  "tests",
+]);
+
+const ROOT_FILE_RE = /^(?:README|CHANGELOG|LICENSE|SECURITY|package|tsconfig|vite\.config|next\.config|bun\.lock)(?:\.[a-z0-9]+)?$/i;
+
+function decodePath(value: string): string {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+
+function stripLinkLabelMarkdown(label: string): string {
+  return label.trim().replace(/^`([^`]+)`$/, "$1").replace(/^\*\*([^*]+)\*\*$/, "$1");
+}
+
+function splitLineAnchor(value: string): { path: string; lineSuffix: string } {
+  const anchorMatch = /#L(\d+)(?:-L?(\d+))?$/i.exec(value);
+  if (!anchorMatch) {
+    return { path: value, lineSuffix: "" };
+  }
+
+  const start = anchorMatch[1]!;
+  const end = anchorMatch[2];
+  return {
+    path: value.slice(0, anchorMatch.index),
+    lineSuffix: end ? `:${start}-${end}` : `:${start}`,
+  };
+}
+
+function normalizeLocalPathPathname(rawPath: string): { path: string; lineSuffix: string } {
+  let value = rawPath.trim();
+  value = value.replace(/^<|>$/g, "");
+  value = value.replace(/^file:(?:\/\/)?/i, "");
+  value = value.replace(/^\/([A-Za-z]:[\\/])/, "$1");
+  value = decodePath(value);
+  value = value.replace(/\\/g, "/");
+  value = value.replace(/[?#][^#]*$/, (suffix) => suffix.startsWith("#L") ? suffix : "");
+  return splitLineAnchor(value);
+}
+
+function looksLikeLocalTarget(target: string): boolean {
+  const trimmed = target.trim();
+  return /^file:/i.test(trimmed)
+    || /^[A-Za-z]:[\\/]/.test(trimmed)
+    || /^\/(?:Users|home|workspace|workspaces|mnt\/[a-z])\//i.test(trimmed);
+}
+
+function looksLikePathLabel(label: string): boolean {
+  return /[\\/]/.test(label) || /^[\w.-]+\.[A-Za-z0-9]+(?::\d+(?:-\d+)?)?$/.test(label);
+}
+
+export function formatLocalPathForTerminal(rawPath: string): string {
+  if (/^https?:\/\//i.test(rawPath.trim())) {
+    return rawPath;
+  }
+
+  const { path, lineSuffix } = normalizeLocalPathPathname(rawPath);
+  const segments = path.split("/").filter(Boolean);
+  if (segments.length === 0) {
+    return path + lineSuffix;
+  }
+
+  const rootIndex = segments.findIndex((segment) => PATH_ROOT_SEGMENTS.has(segment));
+  if (rootIndex >= 0) {
+    return segments.slice(rootIndex).join("/") + lineSuffix;
+  }
+
+  const fileName = segments[segments.length - 1]!;
+  if (ROOT_FILE_RE.test(fileName)) {
+    return fileName + lineSuffix;
+  }
+
+  return segments.slice(-1).join("/") + lineSuffix;
+}
+
+function formatLocalMarkdownLink(label: string, target: string): string {
+  const cleanLabel = stripLinkLabelMarkdown(label);
+  const compactTarget = formatLocalPathForTerminal(target);
+  const lineSuffix = /(:\d+(?:-\d+)?)$/.exec(compactTarget)?.[1] ?? "";
+
+  if (looksLikePathLabel(cleanLabel)) {
+    const compactLabel = formatLocalPathForTerminal(cleanLabel);
+    return lineSuffix && !compactLabel.endsWith(lineSuffix)
+      ? `${compactLabel}${lineSuffix}`
+      : compactLabel;
+  }
+
+  return cleanLabel ? `${cleanLabel} (${compactTarget})` : compactTarget;
+}
+
+export function formatTerminalAnswerInline(text: string): string {
+  if (!text) return text;
+
+  let formatted = text.replace(MARKDOWN_LINK_RE, (full, label: string, target: string) => {
+    if (!looksLikeLocalTarget(target)) {
+      return full;
+    }
+    return formatLocalMarkdownLink(label, target);
+  });
+
+  formatted = formatted.replace(FILE_URL_RE, (match) => formatLocalPathForTerminal(match));
+  formatted = formatted.replace(WINDOWS_ABSOLUTE_PATH_RE, (match) => formatLocalPathForTerminal(match));
+  formatted = formatted.replace(UNIX_ABSOLUTE_PATH_RE, (full, path: string) => {
+    const prefix = full.slice(0, full.length - path.length);
+    return `${prefix}${formatLocalPathForTerminal(path)}`;
+  });
+
+  return formatted;
+}

package/src/ui/textLayout.test.ts

@@ -0,0 +1,18 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { wrapCommandText } from "./textLayout.js";
+
+test("wrapCommandText breaks on spaces and indents continuation lines", () => {
+  const result = wrapCommandText("if (Get-Command rg) { rg --files } else { Get-ChildItem -Recurse -File }", 40);
+  assert.equal(result.length, 2);
+  assert.equal(result[0].trimEnd(), "if (Get-Command rg) { rg --files } else");
+  assert.equal(result[1].trimEnd(), "  { Get-ChildItem -Recurse -File }");
+});
+
+test("wrapCommandText handles extremely long unbroken tokens by breaking them", () => {
+  const result = wrapCommandText("A_Very_Long_Token_Without_Spaces_That_Exceeds_Max_Width", 20);
+  assert.equal(result.length, 3);
+  assert.equal(result[0], "A_Very_Long_Token_Wi");
+  assert.equal(result[1], "  thout_Spaces_That_");
+  assert.equal(result[2], "  Exceeds_Max_Width");
+});

package/src/ui/textLayout.ts

@@ -0,0 +1,338 @@
+import stringWidth from "string-width";
+
+interface WindowSlice {
+  text: string;
+  cursorColumn: number;
+}
+
+export interface TextUnit {
+  text: string;
+  start: number;
+  end: number;
+  width: number;
+}
+
+export interface WrappedTextRow {
+  text: string;
+  start: number;
+  end: number;
+  breakType: "soft" | "hard" | "end";
+}
+
+// ─── Character measurement ───────────────────────────────────────────────────
+
+export function getCharWidth(char: string): number {
+  return Math.max(1, stringWidth(char));
+}
+
+export function normalizeLineBreaks(text: string): string {
+  return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+
+export function getTextUnits(text: string): TextUnit[] {
+  const units: TextUnit[] = [];
+  let offset = 0;
+
+  for (const char of text) {
+    const length = char.length;
+    units.push({
+      text: char,
+      start: offset,
+      end: offset + length,
+      width: getCharWidth(char),
+    });
+    offset += length;
+  }
+
+  return units;
+}
+
+export function getTextWidth(text: string): number {
+  return stringWidth(text);
+}
+
+function trimToWidthFromEnd(text: string, maxWidth: number): string {
+  if (maxWidth <= 0) return "";
+  let width = 0;
+  const kept: TextUnit[] = [];
+  const units = getTextUnits(text);
+
+  for (let index = units.length - 1; index >= 0; index -= 1) {
+    const unit = units[index]!;
+    if (width + unit.width > maxWidth) break;
+    kept.unshift(unit);
+    width += unit.width;
+  }
+
+  return kept.map((unit) => unit.text).join("");
+}
+
+function trimToWidthFromStart(text: string, maxWidth: number): string {
+  if (maxWidth <= 0) return "";
+  let width = 0;
+  let output = "";
+
+  for (const unit of getTextUnits(text)) {
+    if (width + unit.width > maxWidth) break;
+    output += unit.text;
+    width += unit.width;
+  }
+
+  return output;
+}
+
+// ─── Input window ────────────────────────────────────────────────────────────
+
+export function flattenInputForDisplay(text: string, cursor: number): { text: string; cursor: number } {
+  const normalized = normalizeLineBreaks(text);
+  const units = getTextUnits(normalized);
+  let output = "";
+  let mappedCursor = 0;
+
+  for (const unit of units) {
+    if (unit.start === cursor) {
+      mappedCursor = output.length;
+    }
+
+    if (unit.text === "\n") {
+      output += " ↩ ";
+      continue;
+    }
+    if (unit.text === "\t") {
+      output += "  ";
+      continue;
+    }
+    output += unit.text;
+  }
+
+  if (cursor >= normalized.length) {
+    mappedCursor = output.length;
+  }
+
+  return { text: output, cursor: mappedCursor };
+}
+
+export function createInlineInputWindow(text: string, cursor: number, maxWidth: number): WindowSlice {
+  const safeWidth = Math.max(1, maxWidth);
+  const flattened = flattenInputForDisplay(text, cursor);
+  const units = getTextUnits(flattened.text);
+  const charStartWidths: number[] = [];
+  let totalWidth = 0;
+
+  for (const unit of units) {
+    charStartWidths.push(totalWidth);
+    totalWidth += unit.width;
+  }
+
+  const cursorWidth = getTextWidth(flattened.text.slice(0, flattened.cursor));
+  if (totalWidth <= safeWidth) {
+    return { text: flattened.text, cursorColumn: cursorWidth };
+  }
+
+  const preferredStart = Math.max(0, cursorWidth - Math.floor(safeWidth * 0.65));
+  let windowStart = preferredStart;
+  if (windowStart + safeWidth > totalWidth) {
+    windowStart = Math.max(0, totalWidth - safeWidth);
+  }
+  const windowEnd = windowStart + safeWidth;
+
+  let startIndex = 0;
+  while (startIndex < units.length && charStartWidths[startIndex]! + units[startIndex]!.width <= windowStart) {
+    startIndex += 1;
+  }
+
+  let endIndex = startIndex;
+  while (endIndex < units.length && charStartWidths[endIndex]! < windowEnd) {
+    endIndex += 1;
+  }
+
+  let visibleText = units.slice(startIndex, endIndex).map((unit) => unit.text).join("");
+  let cursorColumn = Math.max(0, cursorWidth - (charStartWidths[startIndex] ?? 0));
+  const truncatedLeft = startIndex > 0;
+  const truncatedRight = endIndex < units.length;
+
+  if (truncatedLeft) {
+    const ellipsis = "…";
+    const available = Math.max(1, safeWidth - getCharWidth(ellipsis) - (truncatedRight ? getCharWidth(ellipsis) : 0));
+    visibleText = ellipsis + trimToWidthFromEnd(visibleText, available);
+    cursorColumn = Math.min(getTextWidth(visibleText), Math.max(getCharWidth(ellipsis), cursorColumn + getCharWidth(ellipsis)));
+  }
+
+  if (truncatedRight) {
+    const ellipsis = "…";
+    const available = Math.max(1, safeWidth - (truncatedLeft ? getCharWidth(ellipsis) : 0) - getCharWidth(ellipsis));
+    const baseText = truncatedLeft ? visibleText.slice(1) : visibleText;
+    visibleText = `${truncatedLeft ? "…" : ""}${trimToWidthFromStart(baseText, available)}${ellipsis}`;
+  }
+
+  return {
+    text: visibleText,
+    cursorColumn: Math.max(0, Math.min(getTextWidth(visibleText), cursorColumn)),
+  };
+}
+
+export function splitTextAtColumn(text: string, column: number): { before: string; current: string; after: string } {
+  const safeColumn = Math.max(0, column);
+  let width = 0;
+  const units = getTextUnits(text);
+
+  for (const unit of units) {
+    if (width + unit.width > safeColumn) {
+      return {
+        before: text.slice(0, unit.start),
+        current: unit.text,
+        after: text.slice(unit.end),
+      };
+    }
+
+    width += unit.width;
+    if (width > safeColumn) break;
+  }
+
+  return {
+    before: text,
+    current: "",
+    after: "",
+  };
+}
+
+// ─── Text wrapping ────────────────────────────────────────────────────────────
+
+export function wrapTextRows(text: string, maxWidth: number): WrappedTextRow[] {
+  const normalized = normalizeLineBreaks(text);
+  const safeWidth = Math.max(1, maxWidth);
+  const rows: WrappedTextRow[] = [];
+  let rowStart = 0;
+  let rowText = "";
+  let rowWidth = 0;
+
+  for (const unit of getTextUnits(normalized)) {
+    if (unit.text === "\n") {
+      rows.push({
+        text: rowText,
+        start: rowStart,
+        end: unit.start,
+        breakType: "hard",
+      });
+      rowStart = unit.end;
+      rowText = "";
+      rowWidth = 0;
+      continue;
+    }
+
+    if (rowText.length > 0 && rowWidth + unit.width > safeWidth) {
+      rows.push({
+        text: rowText,
+        start: rowStart,
+        end: unit.start,
+        breakType: "soft",
+      });
+      rowStart = unit.start;
+      rowText = unit.text;
+      rowWidth = unit.width;
+      continue;
+    }
+
+    rowText += unit.text;
+    rowWidth += unit.width;
+  }
+
+  rows.push({
+    text: rowText,
+    start: rowStart,
+    end: normalized.length,
+    breakType: "end",
+  });
+
+  return rows.length > 0 ? rows : [{
+    text: "",
+    start: 0,
+    end: 0,
+    breakType: "end",
+  }];
+}
+
+export function wrapPlainText(text: string, maxWidth: number): string[] {
+  return wrapTextRows(text, maxWidth).map((row) => row.text);
+}
+
+export function wrapCommandText(text: string, maxWidth: number): string[] {
+  if (maxWidth <= 2) return [];
+  const normalized = normalizeLineBreaks(text);
+  const rows: string[] = [];
+  let currentLine = "";
+  let currentWidth = 0;
+  
+  // Split on whitespace, but keep the whitespace tokens
+  const tokens = normalized.split(/([ \t]+)/);
+  
+  for (let i = 0; i < tokens.length; i++) {
+    let token = tokens[i];
+    if (!token) continue;
+    
+    if (token === "\n") {
+      rows.push(currentLine);
+      currentLine = "  ";
+      currentWidth = 2;
+      continue;
+    }
+    
+    let tokenWidth = getTextWidth(token);
+    
+    // Skip leading whitespace on continuation lines
+    if (/^[ \t]+$/.test(token) && currentLine === "  ") {
+      continue;
+    }
+
+    if (currentWidth + tokenWidth > maxWidth) {
+      if (/^[ \t]+$/.test(token)) {
+        // Space that pushes us over the edge, ignore it and break
+        rows.push(currentLine);
+        currentLine = "  ";
+        currentWidth = 2;
+        continue;
+      }
+      
+      if (currentWidth > 2) {
+        // We have some content on this line, push it and start a new line
+        rows.push(currentLine);
+        currentLine = "  ";
+        currentWidth = 2;
+      }
+      
+      // Now check if the token alone exceeds the available width (maxWidth - 2)
+      while (tokenWidth > maxWidth - currentWidth) {
+        const available = maxWidth - currentWidth;
+        const split = splitTextAtColumn(token, available);
+        
+        currentLine += split.before;
+        rows.push(currentLine);
+        
+        token = split.current + split.after;
+        tokenWidth = getTextWidth(token);
+        currentLine = "  ";
+        currentWidth = 2;
+      }
+      
+      currentLine += token;
+      currentWidth += tokenWidth;
+      
+    } else {
+      currentLine += token;
+      currentWidth += tokenWidth;
+    }
+  }
+  
+  if (currentLine.trim().length > 0 || currentLine === "  ") {
+    // only push if there is actual content, or if it is an intentionally empty line (rare)
+    if (currentLine !== "  ") {
+       rows.push(currentLine);
+    }
+  }
+  
+  if (rows.length > 0 && rows[0].startsWith("  ") && !text.startsWith("  ")) {
+    rows[0] = rows[0].substring(2);
+  }
+  
+  return rows;
+}