@assistant-ui/react-ink 0.0.6 → 0.0.7

package/dist/primitives/diff/types.d.ts

@@ -0,0 +1,24 @@
+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;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/primitives/diff/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/primitives/diff/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,YAAY,GAAG,KAAK,GAAG,KAAK,GAAG,QAAQ,CAAC;AAEpD,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,YAAY,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,UAAU;IACzB,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,KAAK,EAAE,UAAU,EAAE,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,MAAM,WAAW,GAAG,UAAU,GAAG,YAAY,CAAC;AAEpD,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC3B"}

package/dist/primitives/diff/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/primitives/diff/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/primitives/diff/types.ts"],"names":[],"mappings":""}

package/dist/primitives/diff.d.ts

@@ -0,0 +1,2 @@
+export * from "./diff/index.js";
+//# sourceMappingURL=diff.d.ts.map

package/dist/primitives/diff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff.d.ts","sourceRoot":"","sources":["../../src/primitives/diff.ts"],"names":[],"mappings":"AAAA,gCAA6B"}

package/dist/primitives/diff.js

@@ -0,0 +1,2 @@
+export * from "./diff/index.js";
+//# sourceMappingURL=diff.js.map

package/dist/primitives/diff.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff.js","sourceRoot":"","sources":["../../src/primitives/diff.ts"],"names":[],"mappings":"AAAA,gCAA6B"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@assistant-ui/react-ink",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "description": "React Ink (terminal UI) bindings for assistant-ui",
   "keywords": [
     "assistant",
@@ -34,12 +34,14 @@
   ],
   "sideEffects": false,
   "dependencies": {
-    "@assistant-ui/core": "^0.1.7",
-    "@assistant-ui/store": "^0.2.3",
-    "@assistant-ui/tap": "^0.5.3",
-    "assistant-stream": "^0.3.6",
+    "@assistant-ui/core": "^0.1.8",
+    "@assistant-ui/store": "^0.2.4",
+    "@assistant-ui/tap": "^0.5.4",
+    "assistant-stream": "^0.3.7",
+    "diff": "^8.0.3",
     "ink-spinner": "^5.0.0",
-    "zustand": "^5.0.11"
+    "parse-diff": "^0.11.1",
+    "zustand": "^5.0.12"
   },
   "peerDependencies": {
     "@types/react": "*",
@@ -55,7 +57,7 @@
     "@types/react": "^19.2.14",
     "ink": "^6.8.0",
     "ink-testing-library": "^4.0.0",
-    "react": "^19.1.0",
+    "react": "^19.2.4",
     "vitest": "^4.1.0",
     "@assistant-ui/x-buildutils": "0.0.3"
   },

package/src/index.ts

@@ -114,6 +114,8 @@ export * as ChainOfThoughtPrimitive from "./primitives/chainOfThought";
 export * as SuggestionPrimitive from "./primitives/suggestion";
 export * as ToolCallPrimitive from "./primitives/toolCall";
 export * as ErrorPrimitive from "./primitives/error";
+export * as DiffPrimitive from "./primitives/diff";
+export { DiffView, type DiffViewProps } from "./primitives/diff/DiffView";
 
 // Re-export shared providers from core/react
 export {

package/src/primitives/composer/ComposerSend.tsx

@@ -15,7 +15,7 @@ export const ComposerSend = ({
 
   return (
     <Pressable
-      onPress={send}
+      onPress={() => send()}
       disabled={disabled ?? hookDisabled}
       {...pressableProps}
     >

package/src/primitives/diff/DiffContent.tsx

@@ -0,0 +1,77 @@
+import { type ComponentProps, type ReactNode, Fragment } from "react";
+import { Box, Text } from "ink";
+import { useMemo } from "react";
+import { useDiffContext } from "./DiffContext";
+import { DiffLine } from "./DiffLine";
+import { foldContext } from "./diff-utils";
+import type { ParsedLine, DisplayLine, FoldedRegion } from "./types";
+
+export type DiffContentProps = ComponentProps<typeof Box> & {
+  fileIndex?: number | undefined;
+  showLineNumbers?: boolean | undefined;
+  contextLines?: number | undefined;
+  maxLines?: number | undefined;
+  renderLine?:
+    | ((props: { line: ParsedLine; index: number }) => ReactNode)
+    | undefined;
+  renderFold?:
+    | ((props: { region: FoldedRegion; index: number }) => ReactNode)
+    | undefined;
+};
+
+export const DiffContent = ({
+  fileIndex = 0,
+  showLineNumbers = true,
+  contextLines,
+  maxLines,
+  renderLine,
+  renderFold,
+  ...boxProps
+}: DiffContentProps) => {
+  const { files } = useDiffContext();
+  const file = files[fileIndex];
+
+  const displayLines: DisplayLine[] = useMemo(() => {
+    if (!file) return [];
+    if (contextLines !== undefined) {
+      return foldContext(file.lines, contextLines);
+    }
+    return file.lines;
+  }, [file, contextLines]);
+
+  if (!file) return null;
+
+  const truncated = maxLines !== undefined && displayLines.length > maxLines;
+  const visibleLines = truncated
+    ? displayLines.slice(0, maxLines)
+    : displayLines;
+  const remainingCount = truncated ? displayLines.length - maxLines! : 0;
+
+  return (
+    <Box flexDirection="column" {...boxProps}>
+      {visibleLines.map((line, i) => {
+        if (line.type === "fold") {
+          if (renderFold) {
+            return (
+              <Fragment key={i}>
+                {renderFold({ region: line, index: i })}
+              </Fragment>
+            );
+          }
+          return (
+            <Text key={i}>{`  --- ${line.hiddenCount} lines hidden ---`}</Text>
+          );
+        }
+        if (renderLine) {
+          return <Fragment key={i}>{renderLine({ line, index: i })}</Fragment>;
+        }
+        return (
+          <DiffLine key={i} line={line} showLineNumbers={showLineNumbers} />
+        );
+      })}
+      {truncated && <Text>{`... (${remainingCount} more lines)`}</Text>}
+    </Box>
+  );
+};
+
+DiffContent.displayName = "DiffPrimitive.Content";

package/src/primitives/diff/DiffContext.tsx

@@ -0,0 +1,18 @@
+import { createContext, useContext } from "react";
+import type { ParsedFile } from "./types";
+
+interface DiffContextValue {
+  files: ParsedFile[];
+}
+
+const DiffContext = createContext<DiffContextValue | null>(null);
+
+export const useDiffContext = (): DiffContextValue => {
+  const ctx = useContext(DiffContext);
+  if (!ctx) {
+    throw new Error("useDiffContext must be used within a DiffRoot");
+  }
+  return ctx;
+};
+
+export const DiffContextProvider = DiffContext.Provider;

package/src/primitives/diff/DiffHeader.tsx

@@ -0,0 +1,38 @@
+import type { ComponentProps } from "react";
+import { Box, Text } from "ink";
+import { useDiffContext } from "./DiffContext";
+import { DiffStats } from "./DiffStats";
+
+export type DiffHeaderProps = ComponentProps<typeof Box> & {
+  fileIndex?: number;
+};
+
+export const DiffHeader = ({ fileIndex = 0, ...boxProps }: DiffHeaderProps) => {
+  const { files } = useDiffContext();
+  const file = files[fileIndex];
+  if (!file) return null;
+
+  const isDevNull = (n: string | undefined) => !n || n === "/dev/null";
+  const renamed =
+    !isDevNull(file.oldName) &&
+    !isDevNull(file.newName) &&
+    file.oldName !== file.newName;
+  const displayName = isDevNull(file.newName) ? file.oldName : file.newName;
+
+  return (
+    <Box gap={1} {...boxProps}>
+      {renamed ? (
+        <>
+          <Text>{file.oldName}</Text>
+          <Text>{"->"}</Text>
+          <Text>{file.newName}</Text>
+        </>
+      ) : (
+        <Text>{displayName}</Text>
+      )}
+      <DiffStats fileIndex={fileIndex} />
+    </Box>
+  );
+};
+
+DiffHeader.displayName = "DiffPrimitive.Header";

package/src/primitives/diff/DiffLine.tsx

@@ -0,0 +1,42 @@
+import type { ComponentProps } from "react";
+import { Box, Text } from "ink";
+import type { ParsedLine } from "./types";
+
+const INDICATOR: Record<ParsedLine["type"], string> = {
+  add: "+",
+  del: "-",
+  normal: " ",
+};
+
+export type DiffLineProps = ComponentProps<typeof Box> & {
+  line: ParsedLine;
+  showLineNumbers?: boolean;
+  lineNumberWidth?: number;
+};
+
+export const DiffLine = ({
+  line,
+  showLineNumbers = true,
+  lineNumberWidth = 4,
+  ...boxProps
+}: DiffLineProps) => {
+  const lineNum =
+    line.type === "del"
+      ? line.oldLineNumber
+      : line.type === "add"
+        ? line.newLineNumber
+        : line.oldLineNumber;
+
+  const numStr = lineNum !== undefined ? String(lineNum) : "";
+  const padded = numStr.padStart(lineNumberWidth);
+  const content = `${INDICATOR[line.type]} ${line.content}`;
+
+  return (
+    <Box {...boxProps}>
+      {showLineNumbers && <Text>{padded} </Text>}
+      <Text>{content}</Text>
+    </Box>
+  );
+};
+
+DiffLine.displayName = "DiffPrimitive.Line";

package/src/primitives/diff/DiffRoot.tsx

@@ -0,0 +1,25 @@
+import type { ComponentProps, ReactNode } from "react";
+import { Box } from "ink";
+import { DiffContextProvider } from "./DiffContext";
+import type { ParsedFile } from "./types";
+
+export type DiffRootProps = ComponentProps<typeof Box> & {
+  files?: ParsedFile[] | undefined;
+  children: ReactNode;
+};
+
+export const DiffRoot = ({
+  files = [],
+  children,
+  ...boxProps
+}: DiffRootProps) => {
+  return (
+    <DiffContextProvider value={{ files }}>
+      <Box flexDirection="column" {...boxProps}>
+        {children}
+      </Box>
+    </DiffContextProvider>
+  );
+};
+
+DiffRoot.displayName = "DiffPrimitive.Root";

package/src/primitives/diff/DiffStats.tsx

@@ -0,0 +1,22 @@
+import type { ComponentProps } from "react";
+import { Box, Text } from "ink";
+import { useDiffContext } from "./DiffContext";
+
+export type DiffStatsProps = ComponentProps<typeof Box> & {
+  fileIndex?: number;
+};
+
+export const DiffStats = ({ fileIndex = 0, ...boxProps }: DiffStatsProps) => {
+  const { files } = useDiffContext();
+  const file = files[fileIndex];
+  if (!file) return null;
+
+  return (
+    <Box gap={1} {...boxProps}>
+      <Text>+{file.additions}</Text>
+      <Text>-{file.deletions}</Text>
+    </Box>
+  );
+};
+
+DiffStats.displayName = "DiffPrimitive.Stats";

package/src/primitives/diff/DiffView.test.tsx

@@ -0,0 +1,340 @@
+import type { ReactElement } from "react";
+import { afterEach, describe, expect, it } from "vitest";
+import { cleanup, render } from "ink-testing-library";
+import { parsePatch, computeDiff, foldContext } from "./diff-utils";
+import { DiffContent } from "./DiffContent";
+import { DiffHeader } from "./DiffHeader";
+import { DiffRoot } from "./DiffRoot";
+import { DiffView } from "./DiffView";
+
+const renderFrame = async (node: ReactElement) => {
+  const instance = render(node);
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  return instance.lastFrame() ?? "";
+};
+
+afterEach(() => {
+  cleanup();
+});
+
+const SAMPLE_PATCH = `diff --git a/hello.txt b/hello.txt
+index 1234567..abcdefg 100644
+--- a/hello.txt
++++ b/hello.txt
+@@ -1,3 +1,4 @@
+ line 1
+-line 2
++line 2 modified
++line 2.5 added
+ line 3
+`;
+
+describe("parsePatch", () => {
+  it("parses a unified diff string", () => {
+    const files = parsePatch(SAMPLE_PATCH);
+    expect(files).toHaveLength(1);
+    const file = files[0]!;
+    expect(file.oldName).toBe("hello.txt");
+    expect(file.newName).toBe("hello.txt");
+    expect(file.additions).toBe(2);
+    expect(file.deletions).toBe(1);
+
+    const types = file.lines.map((l) => l.type);
+    expect(types).toContain("add");
+    expect(types).toContain("del");
+    expect(types).toContain("normal");
+  });
+
+  it("strips CRLF line endings from parsed patch lines", () => {
+    const patch = `diff --git a/x.txt b/x.txt
+--- a/x.txt
++++ b/x.txt
+@@ -1,2 +1,2 @@
+ a\r
+-b\r
++c\r
+`;
+
+    expect(parsePatch(patch)).toEqual([
+      {
+        oldName: "x.txt",
+        newName: "x.txt",
+        additions: 1,
+        deletions: 1,
+        lines: [
+          {
+            type: "normal",
+            content: "a",
+            oldLineNumber: 1,
+            newLineNumber: 1,
+          },
+          {
+            type: "del",
+            content: "b",
+            oldLineNumber: 2,
+          },
+          {
+            type: "add",
+            content: "c",
+            newLineNumber: 2,
+          },
+        ],
+      },
+    ]);
+  });
+
+  it("ignores no-newline markers in unified diff patches", () => {
+    const patch = `diff --git a/a.txt b/a.txt
+--- a/a.txt
++++ b/a.txt
+@@ -1 +1 @@
+-old
+\
++new
+\
+`;
+
+    expect(parsePatch(patch)).toEqual([
+      {
+        oldName: "a.txt",
+        newName: "a.txt",
+        additions: 1,
+        deletions: 1,
+        lines: [
+          {
+            type: "del",
+            content: "old",
+            oldLineNumber: 1,
+          },
+          {
+            type: "add",
+            content: "new",
+            newLineNumber: 1,
+          },
+        ],
+      },
+    ]);
+  });
+});
+
+describe("computeDiff", () => {
+  it("diffs two strings", () => {
+    const result = computeDiff("alpha\nbeta\n", "alpha\ngamma\n");
+    expect(result.additions).toBeGreaterThan(0);
+    expect(result.deletions).toBeGreaterThan(0);
+    const types = result.lines.map((l) => l.type);
+    expect(types).toContain("add");
+    expect(types).toContain("del");
+    expect(types).toContain("normal");
+  });
+
+  it("preserves blank-line additions and deletions", () => {
+    expect(computeDiff("a\n", "a\n\n")).toEqual({
+      additions: 1,
+      deletions: 0,
+      lines: [
+        {
+          type: "normal",
+          content: "a",
+          oldLineNumber: 1,
+          newLineNumber: 1,
+        },
+        {
+          type: "add",
+          content: "",
+          newLineNumber: 2,
+        },
+      ],
+    });
+
+    expect(computeDiff("a\n\n", "a\n")).toEqual({
+      additions: 0,
+      deletions: 1,
+      lines: [
+        {
+          type: "normal",
+          content: "a",
+          oldLineNumber: 1,
+          newLineNumber: 1,
+        },
+        {
+          type: "del",
+          content: "",
+          oldLineNumber: 2,
+        },
+      ],
+    });
+  });
+
+  it("strips CRLF line endings from computed diffs", () => {
+    expect(computeDiff("a\r\nb\r\n", "a\r\nc\r\n")).toEqual({
+      additions: 1,
+      deletions: 1,
+      lines: [
+        {
+          type: "normal",
+          content: "a",
+          oldLineNumber: 1,
+          newLineNumber: 1,
+        },
+        {
+          type: "del",
+          content: "b",
+          oldLineNumber: 2,
+        },
+        {
+          type: "add",
+          content: "c",
+          newLineNumber: 2,
+        },
+      ],
+    });
+  });
+});
+
+describe("foldContext", () => {
+  it("folds unchanged regions beyond contextLines", () => {
+    const lines = [
+      ...Array.from({ length: 10 }, (_, i) => ({
+        type: "normal" as const,
+        content: `line ${i}`,
+        oldLineNumber: i + 1,
+        newLineNumber: i + 1,
+      })),
+      { type: "add" as const, content: "new line", newLineNumber: 11 },
+      ...Array.from({ length: 10 }, (_, i) => ({
+        type: "normal" as const,
+        content: `line ${i + 11}`,
+        oldLineNumber: i + 11,
+        newLineNumber: i + 12,
+      })),
+    ];
+
+    const result = foldContext(lines, 2);
+    const folds = result.filter((l) => l.type === "fold");
+    expect(folds.length).toBeGreaterThan(0);
+    const totalHidden = folds.reduce(
+      (sum, f) => sum + (f.type === "fold" ? f.hiddenCount : 0),
+      0,
+    );
+    expect(totalHidden).toBe(16);
+  });
+});
+
+describe("DiffView", () => {
+  it("supports composing primitives from prepared files", async () => {
+    const frame = await renderFrame(
+      <DiffRoot
+        files={[
+          {
+            oldName: "before.txt",
+            newName: "after.txt",
+            additions: 1,
+            deletions: 1,
+            lines: [
+              {
+                type: "del",
+                content: "before",
+                oldLineNumber: 1,
+              },
+              {
+                type: "add",
+                content: "after",
+                newLineNumber: 1,
+              },
+            ],
+          },
+        ]}
+      >
+        <DiffHeader />
+        <DiffContent />
+      </DiffRoot>,
+    );
+
+    expect(frame).toContain("before.txt");
+    expect(frame).toContain("after.txt");
+    expect(frame).toContain("+1");
+    expect(frame).toContain("-1");
+  });
+
+  it("renders a basic patch", async () => {
+    const frame = await renderFrame(<DiffView patch={SAMPLE_PATCH} />);
+    expect(frame).toContain("hello.txt");
+    expect(frame).toContain("+");
+    expect(frame).toContain("-");
+  });
+
+  it("renders from oldFile/newFile", async () => {
+    const frame = await renderFrame(
+      <DiffView
+        oldFile={{ content: "hello\nworld\n", name: "test.txt" }}
+        newFile={{ content: "hello\nearth\n", name: "test.txt" }}
+      />,
+    );
+    expect(frame).toContain("test.txt");
+    expect(frame).toContain("+");
+    expect(frame).toContain("-");
+  });
+
+  it("hides line numbers when showLineNumbers=false", async () => {
+    const withNumbers = await renderFrame(<DiffView patch={SAMPLE_PATCH} />);
+    const withoutNumbers = await renderFrame(
+      <DiffView patch={SAMPLE_PATCH} showLineNumbers={false} />,
+    );
+    expect(withNumbers.length).toBeGreaterThan(withoutNumbers.length);
+  });
+
+  it("truncates with maxLines", async () => {
+    const manyLines = Array.from({ length: 50 }, (_, i) => `+line${i}`).join(
+      "\n",
+    );
+    const patch = `diff --git a/big.txt b/big.txt
+--- a/big.txt
++++ b/big.txt
+@@ -0,0 +1,50 @@
+${manyLines}
+`;
+    const frame = await renderFrame(<DiffView patch={patch} maxLines={5} />);
+    expect(frame).toContain("more lines");
+  });
+
+  it("folds context lines", async () => {
+    const normalBefore = Array.from({ length: 10 }, (_, i) => ` line${i}`).join(
+      "\n",
+    );
+    const normalAfter = Array.from({ length: 10 }, (_, i) => ` after${i}`).join(
+      "\n",
+    );
+    const patch = `diff --git a/ctx.txt b/ctx.txt
+--- a/ctx.txt
++++ b/ctx.txt
+@@ -1,21 +1,22 @@
+${normalBefore}
++inserted
+${normalAfter}
+`;
+    const frame = await renderFrame(
+      <DiffView patch={patch} contextLines={2} />,
+    );
+    expect(frame).toContain("lines hidden");
+  });
+
+  it("renders multi-file patches", async () => {
+    const patch = `diff --git a/a.txt b/a.txt
+--- a/a.txt
++++ b/a.txt
+@@ -1 +1 @@
+-old a
++new a
+diff --git a/b.txt b/b.txt
+--- a/b.txt
++++ b/b.txt
+@@ -1 +1 @@
+-old b
++new b
+`;
+    const frame = await renderFrame(<DiffView patch={patch} />);
+    expect(frame).toContain("a.txt");
+    expect(frame).toContain("b.txt");
+  });
+});