@assistant-ui/react-ink 0.0.6 → 0.0.7

package/src/primitives/diff/DiffView.tsx

@@ -0,0 +1,204 @@
+import { type ComponentProps, useMemo } from "react";
+import { Box, Text } from "ink";
+import { DiffContent } from "./DiffContent";
+import { useDiffContext } from "./DiffContext";
+import { DiffRoot } from "./DiffRoot";
+import { computeDiff, parsePatch } from "./diff-utils";
+import type {
+  DiffFileInput,
+  FoldedRegion,
+  ParsedFile,
+  ParsedLine,
+} from "./types";
+
+export type DiffViewProps = Omit<ComponentProps<typeof Box>, "children"> & {
+  patch?: string | undefined;
+  oldFile?: DiffFileInput | undefined;
+  newFile?: DiffFileInput | undefined;
+  showLineNumbers?: boolean | undefined;
+  contextLines?: number | undefined;
+  maxLines?: number | undefined;
+};
+
+interface DiffViewInnerProps {
+  showLineNumbers: boolean | undefined;
+  contextLines: number | undefined;
+  maxLines: number | undefined;
+}
+
+const INDICATOR: Record<string, string> = {
+  add: "+",
+  del: "-",
+  normal: " ",
+};
+
+const isDevNull = (n: string | undefined) => !n || n === "/dev/null";
+
+const StyledLine = ({
+  line,
+  showLineNumbers,
+}: {
+  line: ParsedLine;
+  showLineNumbers: boolean;
+}) => {
+  const lineNum =
+    line.type === "del"
+      ? line.oldLineNumber
+      : line.type === "add"
+        ? line.newLineNumber
+        : line.oldLineNumber;
+  const numStr = lineNum !== undefined ? String(lineNum) : "";
+  const padded = numStr.padStart(4);
+  const content = `${INDICATOR[line.type]} ${line.content}`;
+
+  return (
+    <Box>
+      {showLineNumbers && <Text dimColor>{padded} </Text>}
+      {line.type === "add" ? (
+        <Text color="green">{content}</Text>
+      ) : line.type === "del" ? (
+        <Text color="red">{content}</Text>
+      ) : (
+        <Text>{content}</Text>
+      )}
+    </Box>
+  );
+};
+
+const StyledFold = ({ region }: { region: FoldedRegion }) => (
+  <Text dimColor>{`  --- ${region.hiddenCount} lines hidden ---`}</Text>
+);
+
+const DiffViewInner = ({
+  showLineNumbers,
+  contextLines,
+  maxLines,
+}: DiffViewInnerProps) => {
+  const { files } = useDiffContext();
+  const shouldShowLineNumbers = showLineNumbers ?? true;
+
+  if (files.length === 0) {
+    return <Text dimColor>No diff content</Text>;
+  }
+
+  return (
+    <>
+      {files.map((file, i) => {
+        const renamed =
+          !isDevNull(file.oldName) &&
+          !isDevNull(file.newName) &&
+          file.oldName !== file.newName;
+        const displayName = isDevNull(file.newName)
+          ? file.oldName
+          : file.newName;
+
+        return (
+          <Box key={i} flexDirection="column">
+            <Box gap={1}>
+              {renamed ? (
+                <>
+                  <Text bold dimColor>
+                    {file.oldName}
+                  </Text>
+                  <Text dimColor>{"->"}</Text>
+                  <Text bold>{file.newName}</Text>
+                </>
+              ) : (
+                <Text bold>{displayName}</Text>
+              )}
+              <Text color="green">+{file.additions}</Text>
+              <Text color="red">-{file.deletions}</Text>
+            </Box>
+            <DiffContent
+              fileIndex={i}
+              contextLines={contextLines}
+              maxLines={maxLines}
+              renderLine={({ line }) => (
+                <StyledLine
+                  line={line}
+                  showLineNumbers={shouldShowLineNumbers}
+                />
+              )}
+              renderFold={({ region }) => <StyledFold region={region} />}
+            />
+            {i < files.length - 1 && <Text> </Text>}
+          </Box>
+        );
+      })}
+    </>
+  );
+};
+
+const getDiffViewFiles = ({
+  patch,
+  oldFile,
+  newFile,
+}: {
+  patch?: string | undefined;
+  oldFile?: DiffFileInput | undefined;
+  newFile?: DiffFileInput | undefined;
+}): ParsedFile[] => {
+  if (patch) {
+    return parsePatch(patch);
+  }
+
+  if (!oldFile || !newFile) {
+    return [];
+  }
+
+  const { lines, additions, deletions } = computeDiff(
+    oldFile.content,
+    newFile.content,
+  );
+
+  return [
+    {
+      oldName: oldFile.name,
+      newName: newFile.name,
+      lines,
+      additions,
+      deletions,
+    },
+  ];
+};
+
+export const DiffView = ({
+  patch,
+  oldFile,
+  newFile,
+  showLineNumbers,
+  contextLines,
+  maxLines,
+  ...boxProps
+}: DiffViewProps) => {
+  const oldContent = oldFile?.content;
+  const oldName = oldFile?.name;
+  const newContent = newFile?.content;
+  const newName = newFile?.name;
+
+  const files = useMemo(
+    () =>
+      getDiffViewFiles({
+        patch,
+        oldFile:
+          oldContent !== undefined
+            ? { content: oldContent, name: oldName }
+            : undefined,
+        newFile:
+          newContent !== undefined
+            ? { content: newContent, name: newName }
+            : undefined,
+      }),
+    [patch, oldContent, oldName, newContent, newName],
+  );
+
+  return (
+    <DiffRoot files={files} {...boxProps}>
+      <DiffViewInner
+        showLineNumbers={showLineNumbers}
+        contextLines={contextLines}
+        maxLines={maxLines}
+      />
+    </DiffRoot>
+  );
+};

package/src/primitives/diff/diff-utils.ts

@@ -0,0 +1,149 @@
+import { diffLines } from "diff";
+import parseDiff from "parse-diff";
+import type {
+  ParsedLine,
+  ParsedFile,
+  DisplayLine,
+  FoldedRegion,
+} from "./types";
+
+const NO_NEWLINE_MARKER = "\";
+
+const stripTrailingCarriageReturn = (content: string) => {
+  return content.endsWith("\r") ? content.slice(0, -1) : content;
+};
+
+const parseChangeContent = (content: string) => {
+  const normalized = stripTrailingCarriageReturn(content);
+  if (normalized === NO_NEWLINE_MARKER) return null;
+  return stripTrailingCarriageReturn(normalized.slice(1));
+};
+
+const splitDiffLines = (value: string) => {
+  const normalized = value.endsWith("\n") ? value.slice(0, -1) : value;
+  if (normalized.length === 0) {
+    return value.length > 0 ? [""] : [];
+  }
+  return normalized.split("\n").map(stripTrailingCarriageReturn);
+};
+
+export function parsePatch(patch: string): ParsedFile[] {
+  const files = parseDiff(patch);
+  return files.map((file) => {
+    const lines: ParsedLine[] = [];
+    let additions = 0;
+    let deletions = 0;
+
+    for (const chunk of file.chunks) {
+      let oldLine = chunk.oldStart;
+      let newLine = chunk.newStart;
+
+      for (const change of chunk.changes) {
+        const content = parseChangeContent(change.content);
+        if (content === null) continue;
+
+        if (change.type === "add") {
+          additions++;
+          lines.push({
+            type: "add",
+            content,
+            newLineNumber: newLine++,
+          });
+        } else if (change.type === "del") {
+          deletions++;
+          lines.push({
+            type: "del",
+            content,
+            oldLineNumber: oldLine++,
+          });
+        } else {
+          lines.push({
+            type: "normal",
+            content,
+            oldLineNumber: oldLine++,
+            newLineNumber: newLine++,
+          });
+        }
+      }
+    }
+
+    return {
+      oldName: file.from,
+      newName: file.to,
+      lines,
+      additions,
+      deletions,
+    };
+  });
+}
+
+export function computeDiff(
+  oldContent: string,
+  newContent: string,
+): { lines: ParsedLine[]; additions: number; deletions: number } {
+  const changes = diffLines(oldContent, newContent);
+  const lines: ParsedLine[] = [];
+  let oldLine = 1;
+  let newLine = 1;
+  let additions = 0;
+  let deletions = 0;
+
+  for (const change of changes) {
+    for (const content of splitDiffLines(change.value)) {
+      if (change.added) {
+        additions++;
+        lines.push({ type: "add", content, newLineNumber: newLine++ });
+      } else if (change.removed) {
+        deletions++;
+        lines.push({ type: "del", content, oldLineNumber: oldLine++ });
+      } else {
+        lines.push({
+          type: "normal",
+          content,
+          oldLineNumber: oldLine++,
+          newLineNumber: newLine++,
+        });
+      }
+    }
+  }
+
+  return { lines, additions, deletions };
+}
+
+export function foldContext(
+  lines: ParsedLine[],
+  contextLines: number,
+): DisplayLine[] {
+  const ctx = Math.max(0, contextLines);
+  const keep = new Set<number>();
+
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i]!.type !== "normal") {
+      for (
+        let j = Math.max(0, i - ctx);
+        j <= Math.min(lines.length - 1, i + ctx);
+        j++
+      ) {
+        keep.add(j);
+      }
+    }
+  }
+
+  const result: DisplayLine[] = [];
+  let i = 0;
+  while (i < lines.length) {
+    if (keep.has(i)) {
+      result.push(lines[i]!);
+      i++;
+    } else {
+      let hiddenCount = 0;
+      while (i < lines.length && !keep.has(i)) {
+        hiddenCount++;
+        i++;
+      }
+      result.push({ type: "fold", hiddenCount } satisfies FoldedRegion);
+    }
+  }
+
+  return result;
+}

package/src/primitives/diff/index.ts

@@ -0,0 +1,25 @@
+export { DiffRoot as Root, type DiffRootProps as RootProps } from "./DiffRoot";
+export {
+  DiffHeader as Header,
+  type DiffHeaderProps as HeaderProps,
+} from "./DiffHeader";
+export {
+  DiffContent as Content,
+  type DiffContentProps as ContentProps,
+} from "./DiffContent";
+export {
+  DiffLine as Line,
+  type DiffLineProps as LineProps,
+} from "./DiffLine";
+export {
+  DiffStats as Stats,
+  type DiffStatsProps as StatsProps,
+} from "./DiffStats";
+export type {
+  ParsedLine,
+  ParsedFile,
+  DiffFileInput,
+  DiffLineType,
+  DisplayLine,
+  FoldedRegion,
+} from "./types";

package/src/primitives/diff/types.ts

@@ -0,0 +1,28 @@
+export type DiffLineType = "add" | "del" | "normal";
+
+export interface ParsedLine {
+  type: DiffLineType;
+  content: string;
+  oldLineNumber?: number;
+  newLineNumber?: number;
+}
+
+export interface ParsedFile {
+  oldName?: string | undefined;
+  newName?: string | undefined;
+  lines: ParsedLine[];
+  additions: number;
+  deletions: number;
+}
+
+export interface FoldedRegion {
+  type: "fold";
+  hiddenCount: number;
+}
+
+export type DisplayLine = ParsedLine | FoldedRegion;
+
+export interface DiffFileInput {
+  content: string;
+  name?: string | undefined;
+}

package/src/primitives/diff.ts

@@ -0,0 +1 @@
+export * from "./diff/index";