@nextclaw/ui 0.11.20 → 0.11.22

package/src/components/chat/adapters/chat-message.partial-json.ts

@@ -0,0 +1,89 @@
+export type PartialJsonStringValue = {
+  value: string;
+  truncated: boolean;
+};
+
+function decodeJsonStringChar(value: string): string {
+  switch (value) {
+    case '"':
+    case "\\":
+    case "/":
+      return value;
+    case "b":
+      return "\b";
+    case "f":
+      return "\f";
+    case "n":
+      return "\n";
+    case "r":
+      return "\r";
+    case "t":
+      return "\t";
+    default:
+      return value;
+  }
+}
+
+function locatePartialJsonStringValueStart(raw: string, fieldName: string): number | null {
+  const marker = `"${fieldName}"`;
+  const markerIndex = raw.indexOf(marker);
+  if (markerIndex < 0) {
+    return null;
+  }
+  const colonIndex = raw.indexOf(":", markerIndex + marker.length);
+  if (colonIndex < 0) {
+    return null;
+  }
+  let valueStart = colonIndex + 1;
+  while (valueStart < raw.length && /\s/.test(raw[valueStart] ?? "")) {
+    valueStart += 1;
+  }
+  return raw[valueStart] === '"' ? valueStart + 1 : null;
+}
+
+function consumePartialJsonStringValue(
+  raw: string,
+  valueStart: number,
+  maxChars = Number.POSITIVE_INFINITY,
+): PartialJsonStringValue | null {
+  let output = "";
+  let escaped = false;
+  for (let index = valueStart; index < raw.length; index += 1) {
+    const current = raw[index];
+    if (current == null) {
+      break;
+    }
+    if (escaped) {
+      output += decodeJsonStringChar(current);
+      escaped = false;
+      continue;
+    }
+    if (current === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (current === '"') {
+      return { value: output, truncated: false };
+    }
+    output += current;
+    if (output.length >= maxChars) {
+      return { value: output, truncated: true };
+    }
+  }
+  return output.length > 0 ? { value: output, truncated: false } : null;
+}
+
+export function readPartialJsonStringField(
+  raw: string,
+  fieldNames: readonly string[],
+  maxChars = Number.POSITIVE_INFINITY,
+): PartialJsonStringValue | null {
+  for (const fieldName of fieldNames) {
+    const valueStart = locatePartialJsonStringValueStart(raw, fieldName);
+    if (valueStart == null) {
+      continue;
+    }
+    return consumePartialJsonStringValue(raw, valueStart, maxChars);
+  }
+  return null;
+}

package/src/components/chat/adapters/file-operation/card.ts

@@ -0,0 +1,330 @@
+import type { ChatFileOperationBlockViewModel } from "@nextclaw/agent-chat-ui";
+import {
+  buildFullReplaceBlock,
+  buildRawPreviewBlock,
+  parsePatchBlocks,
+  type ParsedBlock,
+} from "@/components/chat/adapters/file-operation/diff";
+import {
+  isRecord,
+  readAfterText,
+  readBeforeText,
+  readNewStartLine,
+  readNonEmptyString,
+  readOldStartLine,
+  readOperation,
+  readPartialRecordPayload,
+  readPatchText,
+  readPath,
+  readRecordPayload,
+} from "@/components/chat/adapters/file-operation/record-readers";
+import { readPartialJsonStringField } from "@/components/chat/adapters/chat-message.partial-json";
+
+type ToolInvocationSource = {
+  toolName: string;
+  status?: string;
+  toolCallId?: string;
+  args?: unknown;
+  parsedArgs?: unknown;
+  result?: unknown;
+};
+
+type FileOperationCardData = {
+  summary?: string;
+  fileOperation?: {
+    blocks: ChatFileOperationBlockViewModel[];
+  };
+};
+
+const FILE_TOOL_NAMES = new Set([
+  "file_change",
+  "read_file",
+  "write_file",
+  "edit_file",
+  "apply_patch",
+]);
+
+function finalizeParsedBlocks(
+  blocks: ParsedBlock[],
+): FileOperationCardData | null {
+  const normalizedBlocks = blocks
+    .map((block, index) => ({
+      key: `${block.path}-${index + 1}`,
+      path: block.path,
+      display: block.display,
+      ...(block.caption ? { caption: block.caption } : {}),
+      lines: block.lines,
+      ...(block.rawText ? { rawText: block.rawText } : {}),
+      ...(block.truncated ? { truncated: true } : {}),
+    }))
+    .filter((block) => block.lines.length > 0 || Boolean(block.rawText));
+
+  if (normalizedBlocks.length === 0) {
+    return null;
+  }
+
+  const paths = normalizedBlocks.map((block) => block.path);
+  const summary =
+    paths.length === 1
+      ? paths[0]
+      : `${paths.length} files · ${paths.slice(0, 2).join(" · ")}${paths.length > 2 ? " …" : ""}`;
+
+  return {
+    summary,
+    fileOperation: {
+      blocks: normalizedBlocks,
+    },
+  };
+}
+
+function buildBlockFromChangeRecord(
+  record: Record<string, unknown>,
+  fallbackPath: string,
+): ParsedBlock | null {
+  const path = readPath(record) ?? fallbackPath;
+  const operation = readOperation(record);
+  const oldStartLine = readOldStartLine(record);
+  const newStartLine = readNewStartLine(record);
+  const patchText = readPatchText(record);
+  if (patchText) {
+    const parsedBlocks = parsePatchBlocks(patchText);
+    if (parsedBlocks.length > 0) {
+      return parsedBlocks[0] ?? null;
+    }
+  }
+
+  const beforeText = readBeforeText(record);
+  const afterText = readAfterText(record);
+  if (beforeText != null || afterText != null) {
+    return buildFullReplaceBlock({
+      path,
+      beforeText,
+      afterText,
+      operation,
+      oldStartLine,
+      newStartLine,
+    });
+  }
+
+  const previewText = readNonEmptyString(record.preview);
+  if (previewText) {
+    return buildRawPreviewBlock({
+      path,
+      text: previewText,
+      operation,
+      oldStartLine,
+      newStartLine,
+    });
+  }
+
+  return null;
+}
+
+function buildBlocksFromChanges(changes: unknown): ParsedBlock[] {
+  if (!Array.isArray(changes)) {
+    return [];
+  }
+
+  const blocks: ParsedBlock[] = [];
+  changes.forEach((entry, index) => {
+    if (typeof entry === "string") {
+      const parsedBlocks = parsePatchBlocks(entry);
+      if (parsedBlocks.length > 0) {
+        blocks.push(...parsedBlocks);
+      }
+      return;
+    }
+    if (!isRecord(entry)) {
+      return;
+    }
+    const path = readPath(entry) ?? `file-${index + 1}`;
+    const block = buildBlockFromChangeRecord(entry, path);
+    if (block) {
+      blocks.push(block);
+      return;
+    }
+    const nestedChanges = Array.isArray(entry.changes)
+      ? buildBlocksFromChanges(entry.changes)
+      : [];
+    if (nestedChanges.length > 0) {
+      blocks.push(...nestedChanges);
+    }
+  });
+  return blocks;
+}
+
+function buildFileChangeCardData(
+  invocation: ToolInvocationSource,
+): FileOperationCardData | null {
+  const sourceRecord =
+    readRecordPayload(invocation.result) ??
+    readRecordPayload(invocation.parsedArgs) ??
+    readRecordPayload(invocation.args);
+  if (!sourceRecord) {
+    return null;
+  }
+  const blocks = buildBlocksFromChanges(sourceRecord.changes);
+  return finalizeParsedBlocks(blocks);
+}
+
+function buildReadFileCardData(
+  invocation: ToolInvocationSource,
+): FileOperationCardData | null {
+  const argsRecord =
+    readRecordPayload(invocation.parsedArgs) ??
+    readRecordPayload(invocation.args) ??
+    readPartialRecordPayload(invocation.args);
+  const path = argsRecord && readPath(argsRecord);
+  const content = readNonEmptyString(invocation.result);
+  if (!path || !content) {
+    return null;
+  }
+  return finalizeParsedBlocks(
+    [
+      buildRawPreviewBlock({
+        path,
+        text: content,
+        operation: "read",
+      }),
+    ].filter((block): block is ParsedBlock => Boolean(block)),
+  );
+}
+
+function buildWriteFileCardData(
+  invocation: ToolInvocationSource,
+): FileOperationCardData | null {
+  const isStreamingPartialCall = invocation.status === "partial-call";
+  if (isStreamingPartialCall && typeof invocation.args === "string") {
+    const pathField = readPartialJsonStringField(invocation.args, [
+      "path",
+      "filePath",
+      "file_path",
+      "targetPath",
+      "target_path",
+      "filename",
+      "name",
+    ]);
+    const contentField = readPartialJsonStringField(invocation.args, [
+      "content",
+      "text",
+      "afterText",
+      "after_text",
+    ]);
+    if (pathField?.value && contentField?.value) {
+      const previewBlock = buildRawPreviewBlock({
+        path: pathField.value,
+        text: contentField.value,
+        operation: "write",
+      });
+      if (previewBlock) {
+        return finalizeParsedBlocks([previewBlock]);
+      }
+    }
+  }
+
+  const argsRecord =
+    readRecordPayload(invocation.parsedArgs) ??
+    readRecordPayload(invocation.args) ??
+    readPartialRecordPayload(invocation.args);
+  if (!argsRecord) {
+    return null;
+  }
+  const path = readPath(argsRecord);
+  const content = readNonEmptyString(argsRecord.content);
+  if (!path || !content) {
+    return null;
+  }
+  return finalizeParsedBlocks(
+    [
+      buildRawPreviewBlock({
+        path,
+        text: content,
+        operation: "write",
+      }),
+    ].filter((block): block is ParsedBlock => Boolean(block)),
+  );
+}
+
+function buildEditFileCardData(
+  invocation: ToolInvocationSource,
+): FileOperationCardData | null {
+  const resultRecord = readRecordPayload(invocation.result);
+  const argsRecord =
+    readRecordPayload(invocation.parsedArgs) ??
+    readRecordPayload(invocation.args) ??
+    readPartialRecordPayload(invocation.args);
+  if (!resultRecord && !argsRecord) {
+    return null;
+  }
+  const path =
+    (resultRecord ? readPath(resultRecord) : null) ??
+    (argsRecord ? readPath(argsRecord) : null);
+  const beforeText =
+    (resultRecord ? readBeforeText(resultRecord) : null) ??
+    (argsRecord ? readBeforeText(argsRecord) : null);
+  const afterText =
+    (resultRecord ? readAfterText(resultRecord) : null) ??
+    (argsRecord ? readAfterText(argsRecord) : null);
+  const oldStartLine =
+    (resultRecord ? readOldStartLine(resultRecord) : null) ??
+    (argsRecord ? readOldStartLine(argsRecord) : null);
+  const newStartLine =
+    (resultRecord ? readNewStartLine(resultRecord) : null) ??
+    (argsRecord ? readNewStartLine(argsRecord) : null);
+  if (!path || (beforeText == null && afterText == null)) {
+    return null;
+  }
+  return finalizeParsedBlocks(
+    [
+      buildFullReplaceBlock({
+        path,
+        beforeText,
+        afterText,
+        operation: "edit",
+        oldStartLine,
+        newStartLine,
+      }),
+    ].filter((block): block is ParsedBlock => Boolean(block)),
+  );
+}
+
+function buildApplyPatchCardData(
+  invocation: ToolInvocationSource,
+): FileOperationCardData | null {
+  const parsedArgsRecord = readRecordPayload(invocation.parsedArgs);
+  const argsRecord =
+    readRecordPayload(invocation.args) ??
+    readPartialRecordPayload(invocation.args);
+  const patchText =
+    readNonEmptyString(invocation.args) ??
+    (parsedArgsRecord ? readNonEmptyString(parsedArgsRecord.patch) : null) ??
+    (argsRecord ? readNonEmptyString(argsRecord.patch) : null);
+  if (!patchText) {
+    return null;
+  }
+  return finalizeParsedBlocks(parsePatchBlocks(patchText));
+}
+
+export function buildFileOperationCardData(
+  invocation: ToolInvocationSource,
+): FileOperationCardData | null {
+  if (!FILE_TOOL_NAMES.has(invocation.toolName)) {
+    return null;
+  }
+  if (invocation.toolName === "file_change") {
+    return buildFileChangeCardData(invocation);
+  }
+  if (invocation.toolName === "read_file") {
+    return buildReadFileCardData(invocation);
+  }
+  if (invocation.toolName === "write_file") {
+    return buildWriteFileCardData(invocation);
+  }
+  if (invocation.toolName === "edit_file") {
+    return buildEditFileCardData(invocation);
+  }
+  if (invocation.toolName === "apply_patch") {
+    return buildApplyPatchCardData(invocation);
+  }
+  return null;
+}