@nextclaw/ui 0.11.21 → 0.11.22

package/src/components/chat/adapters/file-operation/line-builder.ts

@@ -0,0 +1,249 @@
+import type { ChatFileOperationLineViewModel } from "@nextclaw/agent-chat-ui";
+
+const MAX_DIFF_MATRIX_CELLS = 12_000;
+const UNIFIED_DIFF_HUNK_HEADER_PATTERN =
+  /^@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@/;
+
+export function splitLines(value: string): string[] {
+  const normalized = value.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  return normalized === "" ? [] : normalized.split("\n");
+}
+
+export function incrementLineNumber(value?: number): number | undefined {
+  return typeof value === "number" ? value + 1 : undefined;
+}
+
+export function createLine(params: {
+  kind: ChatFileOperationLineViewModel["kind"];
+  text: string;
+  oldLineNumber?: number;
+  newLineNumber?: number;
+}): ChatFileOperationLineViewModel {
+  return {
+    kind: params.kind,
+    text: params.text,
+    ...(typeof params.oldLineNumber === "number"
+      ? { oldLineNumber: params.oldLineNumber }
+      : {}),
+    ...(typeof params.newLineNumber === "number"
+      ? { newLineNumber: params.newLineNumber }
+      : {}),
+  };
+}
+
+export function readUnifiedDiffHunkStart(line: string): {
+  oldLineNumber: number;
+  newLineNumber: number;
+} | null {
+  const match = UNIFIED_DIFF_HUNK_HEADER_PATTERN.exec(line);
+  if (!match) {
+    return null;
+  }
+  return {
+    oldLineNumber: Number(match[1]),
+    newLineNumber: Number(match[2]),
+  };
+}
+
+export function buildPreviewLines(params: {
+  text: string;
+  kind: "add" | "context";
+  oldStartLine: number;
+  newStartLine: number;
+}): ChatFileOperationLineViewModel[] {
+  return splitLines(params.text).map((line, index) =>
+    params.kind === "add"
+      ? createLine({
+          kind: "add",
+          text: line,
+          newLineNumber: params.newStartLine + index,
+        })
+      : createLine({
+          kind: "context",
+          text: line,
+          oldLineNumber: params.oldStartLine + index,
+          newLineNumber: params.newStartLine + index,
+        }),
+  );
+}
+
+function buildFallbackDiffLines(params: {
+  beforeLines: string[];
+  afterLines: string[];
+  oldStartLine?: number;
+  newStartLine?: number;
+}): ChatFileOperationLineViewModel[] {
+  let oldLineNumber = params.oldStartLine;
+  let newLineNumber = params.newStartLine;
+  return [
+    ...params.beforeLines.map((line) => {
+      const nextLine = createLine({
+        kind: "remove",
+        text: line,
+        oldLineNumber,
+      });
+      oldLineNumber = incrementLineNumber(oldLineNumber);
+      return nextLine;
+    }),
+    ...params.afterLines.map((line) => {
+      const nextLine = createLine({
+        kind: "add",
+        text: line,
+        newLineNumber,
+      });
+      newLineNumber = incrementLineNumber(newLineNumber);
+      return nextLine;
+    }),
+  ];
+}
+
+function buildLcsMatrix(params: {
+  beforeLines: string[];
+  afterLines: string[];
+}): number[][] {
+  const matrix: number[][] = Array.from(
+    { length: params.beforeLines.length + 1 },
+    () => Array.from({ length: params.afterLines.length + 1 }, () => 0),
+  );
+  for (
+    let beforeIndex = params.beforeLines.length - 1;
+    beforeIndex >= 0;
+    beforeIndex -= 1
+  ) {
+    for (
+      let afterIndex = params.afterLines.length - 1;
+      afterIndex >= 0;
+      afterIndex -= 1
+    ) {
+      matrix[beforeIndex]![afterIndex] =
+        params.beforeLines[beforeIndex] === params.afterLines[afterIndex]
+          ? (matrix[beforeIndex + 1]![afterIndex + 1] ?? 0) + 1
+          : Math.max(
+              matrix[beforeIndex + 1]![afterIndex] ?? 0,
+              matrix[beforeIndex]![afterIndex + 1] ?? 0,
+            );
+    }
+  }
+  return matrix;
+}
+
+function appendRemainingDiffLines(params: {
+  lines: ChatFileOperationLineViewModel[];
+  beforeLines: string[];
+  afterLines: string[];
+  beforeIndex: number;
+  afterIndex: number;
+  oldLineNumber?: number;
+  newLineNumber?: number;
+}): void {
+  for (
+    let index = params.beforeIndex;
+    index < params.beforeLines.length;
+    index += 1
+  ) {
+    params.lines.push(
+      createLine({
+        kind: "remove",
+        text: params.beforeLines[index] ?? "",
+        oldLineNumber: params.oldLineNumber,
+      }),
+    );
+    params.oldLineNumber = incrementLineNumber(params.oldLineNumber);
+  }
+  for (
+    let index = params.afterIndex;
+    index < params.afterLines.length;
+    index += 1
+  ) {
+    params.lines.push(
+      createLine({
+        kind: "add",
+        text: params.afterLines[index] ?? "",
+        newLineNumber: params.newLineNumber,
+      }),
+    );
+    params.newLineNumber = incrementLineNumber(params.newLineNumber);
+  }
+}
+
+export function buildLineDiff(params: {
+  beforeText: string;
+  afterText: string;
+  oldStartLine?: number;
+  newStartLine?: number;
+}): ChatFileOperationLineViewModel[] {
+  const beforeLines = splitLines(params.beforeText);
+  const afterLines = splitLines(params.afterText);
+  if (beforeLines.length * afterLines.length > MAX_DIFF_MATRIX_CELLS) {
+    return buildFallbackDiffLines({
+      beforeLines,
+      afterLines,
+      oldStartLine: params.oldStartLine,
+      newStartLine: params.newStartLine,
+    });
+  }
+
+  const lcs = buildLcsMatrix({
+    beforeLines,
+    afterLines,
+  });
+  const lines: ChatFileOperationLineViewModel[] = [];
+  let beforeIndex = 0;
+  let afterIndex = 0;
+  let oldLineNumber = params.oldStartLine;
+  let newLineNumber = params.newStartLine;
+  while (beforeIndex < beforeLines.length && afterIndex < afterLines.length) {
+    if (beforeLines[beforeIndex] === afterLines[afterIndex]) {
+      lines.push(
+        createLine({
+          kind: "context",
+          text: beforeLines[beforeIndex] ?? "",
+          oldLineNumber,
+          newLineNumber,
+        }),
+      );
+      beforeIndex += 1;
+      afterIndex += 1;
+      oldLineNumber = incrementLineNumber(oldLineNumber);
+      newLineNumber = incrementLineNumber(newLineNumber);
+      continue;
+    }
+
+    if (
+      (lcs[beforeIndex + 1]![afterIndex] ?? 0) >=
+      (lcs[beforeIndex]![afterIndex + 1] ?? 0)
+    ) {
+      lines.push(
+        createLine({
+          kind: "remove",
+          text: beforeLines[beforeIndex] ?? "",
+          oldLineNumber,
+        }),
+      );
+      beforeIndex += 1;
+      oldLineNumber = incrementLineNumber(oldLineNumber);
+      continue;
+    }
+
+    lines.push(
+      createLine({
+        kind: "add",
+        text: afterLines[afterIndex] ?? "",
+        newLineNumber,
+      }),
+    );
+    afterIndex += 1;
+    newLineNumber = incrementLineNumber(newLineNumber);
+  }
+
+  appendRemainingDiffLines({
+    lines,
+    beforeLines,
+    afterLines,
+    beforeIndex,
+    afterIndex,
+    oldLineNumber,
+    newLineNumber,
+  });
+  return lines;
+}

package/src/components/chat/adapters/file-operation/record-readers.ts

@@ -0,0 +1,233 @@
+import { readPartialJsonStringField } from "@/components/chat/adapters/chat-message.partial-json";
+
+export function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export function readNonEmptyString(value: unknown): string | null {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+
+function normalizePath(value: unknown): string | null {
+  if (typeof value === "string" && value.trim()) {
+    return value.trim();
+  }
+  return null;
+}
+
+function readPositiveInteger(value: unknown): number | null {
+  if (typeof value === "number" && Number.isInteger(value) && value > 0) {
+    return value;
+  }
+  if (typeof value === "string" && /^\d+$/.test(value.trim())) {
+    return Number(value.trim());
+  }
+  return null;
+}
+
+export function readRecordPayload(
+  value: unknown,
+): Record<string, unknown> | null {
+  if (isRecord(value)) {
+    return value;
+  }
+  if (typeof value !== "string") {
+    return null;
+  }
+  const trimmed = value.trim();
+  if (!trimmed.startsWith("{")) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(trimmed) as unknown;
+    return isRecord(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+export function readPartialRecordPayload(
+  value: unknown,
+): Record<string, unknown> | null {
+  if (isRecord(value)) {
+    return value;
+  }
+  if (typeof value !== "string") {
+    return null;
+  }
+  const trimmed = value.trim();
+  if (!trimmed.startsWith("{")) {
+    return null;
+  }
+  const path =
+    readPartialJsonStringField(trimmed, [
+      "path",
+      "filePath",
+      "file_path",
+      "targetPath",
+      "target_path",
+      "filename",
+      "name",
+    ])?.value ?? null;
+  const content =
+    readPartialJsonStringField(trimmed, [
+      "content",
+      "text",
+      "afterText",
+      "after_text",
+    ])?.value ?? null;
+  const oldText =
+    readPartialJsonStringField(trimmed, [
+      "oldText",
+      "beforeText",
+      "before_text",
+    ])?.value ?? null;
+  const newText =
+    readPartialJsonStringField(trimmed, ["newText", "afterText", "after_text"])
+      ?.value ?? null;
+  const patch =
+    readPartialJsonStringField(trimmed, [
+      "patch",
+      "diff",
+      "unifiedDiff",
+      "unified_diff",
+    ])?.value ?? null;
+
+  const partialRecord: Record<string, unknown> = {};
+  if (path) {
+    partialRecord.path = path;
+  }
+  if (content) {
+    partialRecord.content = content;
+  }
+  if (oldText) {
+    partialRecord.oldText = oldText;
+  }
+  if (newText) {
+    partialRecord.newText = newText;
+  }
+  if (patch) {
+    partialRecord.patch = patch;
+  }
+
+  return Object.keys(partialRecord).length > 0 ? partialRecord : null;
+}
+
+export function readPath(record: Record<string, unknown>): string | null {
+  return (
+    normalizePath(record.path) ??
+    normalizePath(record.filePath) ??
+    normalizePath(record.file_path) ??
+    normalizePath(record.targetPath) ??
+    normalizePath(record.target_path) ??
+    normalizePath(record.filename) ??
+    normalizePath(record.name)
+  );
+}
+
+export function readOperation(record: Record<string, unknown>): string | null {
+  return (
+    readNonEmptyString(record.operation) ??
+    readNonEmptyString(record.op) ??
+    readNonEmptyString(record.action) ??
+    readNonEmptyString(record.kind) ??
+    readNonEmptyString(record.type) ??
+    readNonEmptyString(record.status)
+  );
+}
+
+function readLineStart(
+  record: Record<string, unknown>,
+  keys: string[],
+): number | null {
+  for (const key of keys) {
+    const value = readPositiveInteger(record[key]);
+    if (value !== null) {
+      return value;
+    }
+  }
+  return null;
+}
+
+export function readOldStartLine(
+  record: Record<string, unknown>,
+): number | null {
+  return readLineStart(record, [
+    "oldStartLine",
+    "old_start_line",
+    "startOldLine",
+    "start_old_line",
+    "oldLineStart",
+    "old_line_start",
+    "oldLineNumber",
+    "old_line_number",
+    "lineStart",
+    "line_start",
+    "startLine",
+    "start_line",
+    "lineNumber",
+    "line_number",
+  ]);
+}
+
+export function readNewStartLine(
+  record: Record<string, unknown>,
+): number | null {
+  return readLineStart(record, [
+    "newStartLine",
+    "new_start_line",
+    "startNewLine",
+    "start_new_line",
+    "newLineStart",
+    "new_line_start",
+    "newLineNumber",
+    "new_line_number",
+    "lineStart",
+    "line_start",
+    "startLine",
+    "start_line",
+    "lineNumber",
+    "line_number",
+  ]);
+}
+
+export function readPatchText(record: Record<string, unknown>): string | null {
+  return (
+    readNonEmptyString(record.patch) ??
+    readNonEmptyString(record.diff) ??
+    readNonEmptyString(record.unifiedDiff) ??
+    readNonEmptyString(record.unified_diff)
+  );
+}
+
+export function readBeforeText(record: Record<string, unknown>): string | null {
+  return (
+    readNonEmptyString(record.beforeText) ??
+    readNonEmptyString(record.before_text) ??
+    readNonEmptyString(record.oldText) ??
+    readNonEmptyString(record.old_text) ??
+    readNonEmptyString(record.oldContent) ??
+    readNonEmptyString(record.old_content) ??
+    readNonEmptyString(record.before) ??
+    readNonEmptyString(record.previous)
+  );
+}
+
+export function readAfterText(record: Record<string, unknown>): string | null {
+  return (
+    readNonEmptyString(record.afterText) ??
+    readNonEmptyString(record.after_text) ??
+    readNonEmptyString(record.newText) ??
+    readNonEmptyString(record.new_text) ??
+    readNonEmptyString(record.newContent) ??
+    readNonEmptyString(record.new_content) ??
+    readNonEmptyString(record.content) ??
+    readNonEmptyString(record.text) ??
+    readNonEmptyString(record.after) ??
+    readNonEmptyString(record.updated)
+  );
+}

package/src/components/chat/chat-composer-state.ts

@@ -55,7 +55,7 @@ export function deriveSelectedAttachmentIdsFromComposer(nodes: ChatComposerNode[
 export function syncComposerSkills(
   nodes: ChatComposerNode[],
   nextSkills: string[],
-  skillRecords: Array<{ spec: string; label?: string }>
+  skillRecords: Array<{ ref: string; name: string }>
 ): ChatComposerNode[] {
   const nextSkillSet = new Set(nextSkills);
   const prunedNodes = removeChatComposerTokenNodes(
@@ -63,14 +63,14 @@ export function syncComposerSkills(
     (node) => node.tokenKind === 'skill' && !nextSkillSet.has(node.tokenKey)
   );
   const existingSkills = extractChatComposerTokenKeys(prunedNodes, 'skill');
-  const recordMap = new Map(skillRecords.map((record) => [record.spec, record]));
+  const recordMap = new Map(skillRecords.map((record) => [record.ref, record]));
   const appendedNodes = nextSkills
     .filter((skill) => !existingSkills.includes(skill))
     .map((skill) =>
       createChatComposerTokenNode({
         tokenKind: 'skill',
         tokenKey: skill,
-        label: recordMap.get(skill)?.label || skill
+        label: recordMap.get(skill)?.name || skill
       })
     );
 

package/src/components/chat/chat-session-display.test.ts

@@ -27,6 +27,27 @@ describe('chat-session-display', () => {
     expect(sessionMatchesQuery(createSession({ label: 'VIP Alpha Thread' }), 'alpha')).toBe(true);
   });
 
+  it('matches the search query against the project name and path', () => {
+    expect(
+      sessionMatchesQuery(
+        createSession({
+          projectRoot: '/Users/demo/workspace/project-apollo',
+          projectName: 'project-apollo'
+        }),
+        'apollo'
+      )
+    ).toBe(true);
+    expect(
+      sessionMatchesQuery(
+        createSession({
+          projectRoot: '/Users/demo/workspace/project-apollo',
+          projectName: 'project-apollo'
+        }),
+        'workspace/project'
+      )
+    ).toBe(true);
+  });
+
   it('treats an empty query as a match', () => {
     expect(sessionMatchesQuery(createSession({ label: 'Anything' }), '   ')).toBe(true);
   });

package/src/components/chat/chat-session-display.ts

@@ -18,7 +18,12 @@ export function sessionMatchesQuery(session: SessionEntryView, query: string): b
     return true;
   }
 
-  return [session.key, sessionDisplayName(session)]
+  return [
+    session.key,
+    sessionDisplayName(session),
+    session.projectRoot ?? '',
+    session.projectName ?? '',
+  ]
     .map(normalizeSessionSearchValue)
     .some((value) => value.includes(normalizedQuery));
 }

package/src/components/chat/containers/chat-input-bar.container.tsx

@@ -27,6 +27,7 @@ import {
 } from '@/components/chat/chat-recent-skills.manager';
 import { useI18n } from '@/components/providers/I18nProvider';
 import { useChatInputStore } from '@/components/chat/stores/chat-input.store';
+import type { SessionSkillEntryView } from '@/api/types';
 import { t } from '@/lib/i18n';
 import { toast } from 'sonner';
 
@@ -42,19 +43,17 @@ function buildThinkingLabels(): Record<ChatThinkingLevel, string> {
   };
 }
 
-function toSkillRecords(snapshotRecords: Array<{
-  spec: string;
-  label?: string;
-  description?: string;
-  descriptionZh?: string;
-  origin?: string;
-}>, officialBadgeLabel: string): ChatSkillRecord[] {
+function toSkillRecords(
+  snapshotRecords: SessionSkillEntryView[],
+  scopeLabels: Record<SessionSkillEntryView['scope'], string>
+): ChatSkillRecord[] {
   return snapshotRecords.map((record) => ({
-    key: record.spec,
-    label: record.label || record.spec,
+    key: record.ref,
+    label: record.name,
+    scopeLabel: scopeLabels[record.scope],
     description: record.description,
     descriptionZh: record.descriptionZh,
-    badgeLabel: record.origin === 'builtin' ? officialBadgeLabel : undefined
+    badgeLabel: scopeLabels[record.scope]
   }));
 }
 
@@ -88,20 +87,18 @@ export function ChatInputBarContainer() {
   const inputBarRef = useRef<ChatInputBarHandle | null>(null);
   const fileInputRef = useRef<HTMLInputElement | null>(null);
 
-  const officialSkillBadgeLabel = useMemo(() => {
-    // Keep memo reactive to locale switches even though `t` is imported as a stable function.
-    const locale = language;
-    void locale;
-    return t('chatSkillsPickerOfficial');
+  const skillScopeLabels = useMemo<Record<'project' | 'workspace', string>>(() => {
+    return {
+      project: t('chatSkillScopeProject'),
+      workspace: t('chatSkillScopeWorkspace'),
+    };
   }, [language]);
   const slashTexts = useMemo(
     () => {
-      // Keep memo reactive to locale switches even though `t` is imported as a stable function.
-      const locale = language;
-      void locale;
       return {
         slashSkillSubtitle: t('chatSlashTypeSkill'),
         slashSkillSpecLabel: t('chatSlashSkillSpec'),
+        slashSkillScopeLabel: t('chatSlashSkillScope'),
         noSkillDescription: t('chatSkillsPickerNoDescription')
       };
     },
@@ -109,8 +106,8 @@ export function ChatInputBarContainer() {
   );
 
   const skillRecords = useMemo(
-    () => toSkillRecords(snapshot.skillRecords, officialSkillBadgeLabel),
-    [snapshot.skillRecords, officialSkillBadgeLabel]
+    () => toSkillRecords(snapshot.skillRecords, skillScopeLabels),
+    [snapshot.skillRecords, skillScopeLabels]
   );
   const modelRecords = useMemo(() => toModelRecords(snapshot.modelOptions), [snapshot.modelOptions]);
   const recentModelValues = chatRecentModelsManager.resolveVisible({
@@ -137,10 +134,10 @@ export function ChatInputBarContainer() {
     : hasModelOptions
       ? t('chatInputPlaceholder')
       : t('chatModelNoOptions');
-  const recentModelsLabel = language === 'zh' ? '最近选择' : 'Recent';
-  const allModelsLabel = language === 'zh' ? '全部模型' : 'All models';
-  const recentSkillsLabel = language === 'zh' ? '最近使用' : 'Recent';
-  const allSkillsLabel = language === 'zh' ? '全部技能' : 'All skills';
+  const recentModelsLabel = t('chatPickerRecentModels');
+  const allModelsLabel = t('chatPickerAllModels');
+  const recentSkillsLabel = t('chatPickerRecent');
+  const allSkillsLabel = t('chatPickerAllSkills');
 
   const slashItems = useMemo(
     () => buildChatSlashItems(skillRecords, slashQuery ?? '', slashTexts, recentSkillValues),

package/src/components/chat/hooks/use-chat-session-label.ts

@@ -0,0 +1,19 @@
+import { t } from '@/lib/i18n';
+import { useChatSessionUpdate } from '@/components/chat/hooks/use-chat-session-update';
+
+type UpdateChatSessionLabelParams = {
+  sessionKey: string;
+  label: string | null;
+};
+
+export function useChatSessionLabel() {
+  const updateSession = useChatSessionUpdate();
+
+  return async (params: UpdateChatSessionLabelParams): Promise<void> => {
+    await updateSession({
+      sessionKey: params.sessionKey,
+      patch: { label: params.label },
+      successMessage: t('configSavedApplied'),
+    });
+  };
+}