@nextclaw/ui 0.15.21 → 0.15.23

package/src/features/chat/features/message/hooks/use-chat-message-actions.tsx

@@ -0,0 +1,187 @@
+import { useCallback, useMemo, useState } from 'react';
+import type { NcpMessage } from '@nextclaw/ncp';
+import type {
+  ChatMessageActionViewModel,
+  ChatMessageViewModel,
+} from '@nextclaw/agent-chat-ui';
+
+import {
+  CHAT_INLINE_TOKENS_METADATA_KEY,
+  readInlineTokensFromMetadata,
+} from '@/features/chat/features/input/utils/chat-inline-token.utils';
+import { deriveNcpMessagePartsFromComposer } from '@/features/chat/features/input/utils/chat-composer-state.utils';
+import { buildChatRunMetadata } from '@/features/chat/features/session/utils/chat-run-metadata.utils';
+import { ChatMessageInlineEditor } from '@/features/chat/features/message/components/chat-message-inline-editor';
+import { resolveChatMessageActionTargets } from '@/features/chat/features/message/utils/chat-message-action-targets.utils';
+import {
+  buildSessionMessageComposerSnapshot,
+  type SessionMessageComposerSnapshot,
+} from '@/features/chat/features/conversation/utils/session-message-composer.utils';
+import { t } from '@/shared/lib/i18n';
+
+type EditingMessageState = {
+  readonly message: NcpMessage;
+  readonly snapshot: SessionMessageComposerSnapshot;
+};
+
+function hasSendableParts(parts: NcpMessage['parts']): boolean {
+  return parts.some((part) =>
+    part.type === 'text' || part.type === 'rich-text' || part.type === 'reasoning'
+      ? part.text.trim().length > 0
+      : true,
+  );
+}
+
+function buildEditedMessageMetadata(
+  message: NcpMessage,
+  snapshot: SessionMessageComposerSnapshot,
+): Record<string, unknown> | undefined {
+  const metadata = { ...message.metadata };
+  delete metadata.requested_skill_refs;
+  delete metadata[CHAT_INLINE_TOKENS_METADATA_KEY];
+  const skillRecords = readInlineTokensFromMetadata(message.metadata).flatMap(
+    (token) =>
+      token.kind === 'skill' &&
+      'ref' in token &&
+      token.source &&
+      token.path
+        ? [{
+            name: token.name,
+            path: token.path,
+            ref: token.ref,
+            source: token.source,
+          }]
+        : [],
+  );
+  Object.assign(metadata, buildChatRunMetadata({
+    composerNodes: [...snapshot.nodes],
+    requestedSkills: [...snapshot.selectedSkills],
+    skillRecords,
+  }));
+  return Object.keys(metadata).length > 0 ? metadata : undefined;
+}
+
+export function useChatMessageActions({
+  adaptedMessages,
+  canContinue,
+  disabled,
+  onContinueRun,
+  onEditMessage,
+  rawMessages,
+}: {
+  readonly adaptedMessages: readonly ChatMessageViewModel[];
+  readonly canContinue: boolean;
+  readonly disabled: boolean;
+  readonly onContinueRun?: () => Promise<void> | void;
+  readonly onEditMessage?: (payload: {
+    readonly message: NcpMessage;
+    readonly messageId: string;
+  }) => Promise<void> | void;
+  readonly rawMessages: readonly NcpMessage[];
+}) {
+  const actionTargets = useMemo(
+    () => resolveChatMessageActionTargets({
+      canContinue,
+      isBusy: disabled,
+      messages: rawMessages,
+    }),
+    [canContinue, disabled, rawMessages],
+  );
+  const messages = useMemo(
+    () => adaptedMessages.map((message) => {
+      const actions: ChatMessageActionViewModel[] = [];
+      if (onEditMessage && message.id === actionTargets.editableUserMessageId) {
+        actions.push({
+          disabled,
+          icon: 'edit',
+          key: 'edit-message',
+          label: t('chatEditMessage'),
+        });
+      }
+      if (
+        onContinueRun &&
+        message.id === actionTargets.continuationAssistantMessageId
+      ) {
+        actions.push({
+          disabled,
+          icon: 'continue',
+          key: 'continue-run',
+          label: t('chatContinueRun'),
+        });
+      }
+      return actions.length > 0 ? { ...message, actions } : message;
+    }),
+    [actionTargets, adaptedMessages, disabled, onContinueRun, onEditMessage],
+  );
+  const [editingMessage, setEditingMessage] = useState<EditingMessageState | null>(null);
+  const handleMessageAction = useCallback((
+    message: ChatMessageViewModel,
+    action: ChatMessageActionViewModel,
+  ) => {
+    if (action.key === 'continue-run') {
+      void Promise.resolve(onContinueRun?.()).catch(() => undefined);
+      return;
+    }
+    if (action.key !== 'edit-message' || !onEditMessage) {
+      return;
+    }
+    const sourceMessage = rawMessages.find((item) => item.id === message.id);
+    if (!sourceMessage) {
+      return;
+    }
+    setEditingMessage({
+      message: sourceMessage,
+      snapshot: buildSessionMessageComposerSnapshot({
+        attachmentIdPrefix: `edited-attachment-${sourceMessage.id}`,
+        availableSkills: [],
+        message: sourceMessage,
+      }),
+    });
+  }, [onContinueRun, onEditMessage, rawMessages]);
+  const saveEditedMessage = useCallback(async () => {
+    if (!editingMessage || !onEditMessage) {
+      return;
+    }
+    const parts = deriveNcpMessagePartsFromComposer(
+      [...editingMessage.snapshot.nodes],
+      editingMessage.snapshot.attachments,
+    );
+    if (!hasSendableParts(parts)) {
+      return;
+    }
+    await onEditMessage({
+      messageId: editingMessage.message.id,
+      message: {
+        ...editingMessage.message,
+        id: `edited-message-${globalThis.crypto.randomUUID()}`,
+        metadata: buildEditedMessageMetadata(
+          editingMessage.message,
+          editingMessage.snapshot,
+        ),
+        parts,
+        role: 'user',
+        status: 'final',
+        timestamp: new Date().toISOString(),
+      },
+    });
+    setEditingMessage(null);
+  }, [editingMessage, onEditMessage]);
+  const renderMessageContent = useCallback(
+    (message: ChatMessageViewModel) =>
+      editingMessage?.message.id === message.id ? (
+        <ChatMessageInlineEditor
+          disabled={disabled}
+          messageId={editingMessage.message.id}
+          onCancel={() => setEditingMessage(null)}
+          onChange={(snapshot) => setEditingMessage((current) =>
+            current ? { ...current, snapshot } : null
+          )}
+          onSave={saveEditedMessage}
+          snapshot={editingMessage.snapshot}
+        />
+      ) : undefined,
+    [disabled, editingMessage, saveEditedMessage],
+  );
+
+  return { handleMessageAction, messages, renderMessageContent };
+}

package/src/features/chat/features/message/utils/__tests__/chat-message-action-targets.utils.test.ts

@@ -0,0 +1,89 @@
+import { describe, expect, it } from 'vitest';
+import {
+  NCP_INTERNAL_VISIBILITY_METADATA_KEY,
+  type NcpMessage,
+} from '@nextclaw/ncp';
+import { CHAT_CONTINUATION_TARGET_MESSAGE_METADATA_KEY } from '@nextclaw/shared';
+
+import { resolveChatMessageActionTargets } from '@/features/chat/features/message/utils/chat-message-action-targets.utils';
+
+function message(id: string, role: NcpMessage['role']): NcpMessage {
+  return {
+    id,
+    sessionId: 'session-1',
+    role,
+    status: 'final',
+    timestamp: '2026-08-08T10:00:00.000Z',
+    parts: [{ type: 'text', text: id }],
+  };
+}
+
+describe('resolveChatMessageActionTargets', () => {
+  it('edits only the latest visible user message', () => {
+    expect(resolveChatMessageActionTargets({
+      canContinue: false,
+      isBusy: false,
+      messages: [
+        message('user-1', 'user'),
+        message('assistant-1', 'assistant'),
+        message('user-2', 'user'),
+        message('assistant-2', 'assistant'),
+      ],
+    })).toEqual({
+      continuationAssistantMessageId: null,
+      editableUserMessageId: 'user-2',
+    });
+  });
+
+  it('places continuation on the last partial assistant message', () => {
+    expect(resolveChatMessageActionTargets({
+      canContinue: true,
+      isBusy: false,
+      messages: [message('user-1', 'user'), message('assistant-1', 'assistant')],
+    })).toEqual({
+      continuationAssistantMessageId: 'assistant-1',
+      editableUserMessageId: 'user-1',
+    });
+  });
+
+  it('uses only the composer continuation entry when no assistant reply exists', () => {
+    expect(resolveChatMessageActionTargets({
+      canContinue: true,
+      isBusy: false,
+      messages: [message('user-1', 'user')],
+    })).toEqual({
+      continuationAssistantMessageId: null,
+      editableUserMessageId: 'user-1',
+    });
+  });
+
+  it('places repeated continuation on the canonical interrupted message', () => {
+    expect(resolveChatMessageActionTargets({
+      canContinue: true,
+      isBusy: false,
+      messages: [
+        message('user-1', 'user'),
+        message('assistant-1', 'assistant'),
+        {
+          ...message('continue-1', 'user'),
+          metadata: {
+            [NCP_INTERNAL_VISIBILITY_METADATA_KEY]: 'hidden',
+            [CHAT_CONTINUATION_TARGET_MESSAGE_METADATA_KEY]: 'assistant-1',
+          },
+        },
+        message('assistant-2', 'assistant'),
+      ],
+    })).toEqual({
+      continuationAssistantMessageId: 'assistant-1',
+      editableUserMessageId: 'user-1',
+    });
+  });
+
+  it('hides edit entirely while a run is active', () => {
+    expect(resolveChatMessageActionTargets({
+      canContinue: false,
+      isBusy: true,
+      messages: [message('user-1', 'user'), message('assistant-1', 'assistant')],
+    }).editableUserMessageId).toBeNull();
+  });
+});

package/src/features/chat/features/message/utils/__tests__/chat-message-timeline-compaction.utils.test.ts

@@ -0,0 +1,194 @@
+import { describe, expect, it } from "vitest";
+import {
+  NCP_INTERNAL_VISIBILITY_METADATA_KEY,
+  type NcpMessage,
+} from "@nextclaw/ncp";
+import { CHAT_CONTINUATION_TARGET_MESSAGE_METADATA_KEY } from "@nextclaw/shared";
+import {
+  buildChatMessageTimelineItems,
+  CONTEXT_COMPACTION_PART_EXTENSION_TYPE,
+  projectVisibleChatMessages,
+} from "@/features/chat/features/message/utils/chat-message-timeline.utils";
+
+const visibleMessage = {
+  id: "assistant-visible",
+  sessionId: "session-1",
+  role: "assistant",
+  status: "final",
+  timestamp: "2026-08-07T00:00:00.000Z",
+  parts: [{ type: "text", text: "visible" }],
+} satisfies NcpMessage;
+
+function createCompactionMessage(params: {
+  assistantId: string;
+  coveredPartCount: number;
+  id: string;
+  status?: "compressing" | "compressed";
+  summary?: string;
+}): NcpMessage {
+  const { assistantId, coveredPartCount, id, status, summary } = params;
+  return {
+    ...visibleMessage,
+    id,
+    role: "service",
+    parts: [],
+    metadata: {
+      nextclaw_timeline_kind: "context_compaction",
+      checkpoint: {
+        id: `checkpoint-${id}`,
+        status: status ?? "compressed",
+        phase: "mid-run",
+        continuationMessageId: assistantId,
+        continuationMessageCoveredPartCount: coveredPartCount,
+        summary: summary ?? "Compressed context",
+        coveredMessageCount: coveredPartCount,
+        coveredSessionMessageCount: coveredPartCount,
+        originalEstimatedTokens: 34_000,
+        projectedEstimatedTokens: 26_000,
+        createdAt: "2026-08-07T00:00:50.000Z",
+        updatedAt: "2026-08-07T00:01:00.000Z",
+      },
+    },
+  };
+}
+
+describe("mid-run compaction timeline projection", () => {
+  it("projects an empty-summary compressing marker inside the active assistant boundary", () => {
+    const activeAssistant = {
+      ...visibleMessage,
+      status: "streaming" as const,
+      parts: [
+        { type: "text" as const, text: "before" },
+        { type: "reasoning" as const, text: "covered reasoning" },
+        { type: "text" as const, text: "after" },
+      ],
+    };
+    const compactionMessage = createCompactionMessage({
+      assistantId: activeAssistant.id,
+      coveredPartCount: 2,
+      id: "context-compaction-mid-run",
+      status: "compressing",
+      summary: "",
+    });
+
+    const projected = projectVisibleChatMessages([activeAssistant, compactionMessage]);
+    expect(projected).toHaveLength(1);
+    expect(projected[0]?.parts.map((part) => part.type)).toEqual([
+      "text",
+      "reasoning",
+      "extension",
+      "text",
+    ]);
+    expect(projected[0]?.parts[2]).toMatchObject({
+      type: "extension",
+      extensionType: CONTEXT_COMPACTION_PART_EXTENSION_TYPE,
+      data: { id: compactionMessage.id },
+    });
+    expect(buildChatMessageTimelineItems({
+      rawMessages: [activeAssistant, compactionMessage],
+      messages: [{ id: activeAssistant.id } as never],
+    }).map((item) => item.kind)).toEqual(["message"]);
+  });
+
+  it("keeps repeated compactions ordered inside one assistant message", () => {
+    const activeAssistant = {
+      ...visibleMessage,
+      status: "streaming" as const,
+      parts: ["one", "two", "three", "four"].map((text) => ({
+        type: "text" as const,
+        text,
+      })),
+    };
+    const first = createCompactionMessage({
+      assistantId: activeAssistant.id,
+      coveredPartCount: 1,
+      id: "context-compaction-1",
+    });
+    const second = createCompactionMessage({
+      assistantId: activeAssistant.id,
+      coveredPartCount: 3,
+      id: "context-compaction-2",
+    });
+
+    const [projectedMessage] = projectVisibleChatMessages([
+      activeAssistant,
+      first,
+      second,
+    ]);
+    expect(projectedMessage?.parts.map((part) =>
+      part.type === "extension"
+        ? (part.data as { id: string }).id
+        : part.type === "text"
+          ? part.text
+          : part.type,
+    )).toEqual([
+      "one",
+      first.id,
+      "two",
+      "three",
+      second.id,
+      "four",
+    ]);
+  });
+
+  it("does not silently clamp an invalid canonical part boundary", () => {
+    const invalidCompaction = createCompactionMessage({
+      assistantId: visibleMessage.id,
+      coveredPartCount: 2,
+      id: "context-compaction-invalid-boundary",
+    });
+
+    expect(projectVisibleChatMessages([
+      visibleMessage,
+      invalidCompaction,
+    ])[0]?.parts).toEqual(visibleMessage.parts);
+    expect(buildChatMessageTimelineItems({
+      rawMessages: [visibleMessage, invalidCompaction],
+      messages: [{ id: visibleMessage.id } as never],
+    }).map((item) => item.kind)).toEqual(["message", "compaction"]);
+  });
+
+  it("offsets a continued assistant compaction within its canonical message", () => {
+    const continuationPrompt: NcpMessage = {
+      ...visibleMessage,
+      id: "continue-1",
+      role: "user",
+      parts: [],
+      metadata: {
+        [NCP_INTERNAL_VISIBILITY_METADATA_KEY]: "hidden",
+        [CHAT_CONTINUATION_TARGET_MESSAGE_METADATA_KEY]: visibleMessage.id,
+      },
+    };
+    const continuationAssistant: NcpMessage = {
+      ...visibleMessage,
+      id: "assistant-continuation",
+      parts: [
+        { type: "text", text: "continued-1" },
+        { type: "text", text: "continued-2" },
+        { type: "text", text: "continued-3" },
+      ],
+    };
+    const compactionMessage = createCompactionMessage({
+      assistantId: continuationAssistant.id,
+      coveredPartCount: 2,
+      id: "context-compaction-continuation",
+    });
+
+    const [projectedMessage] = projectVisibleChatMessages([
+      visibleMessage,
+      continuationPrompt,
+      continuationAssistant,
+      compactionMessage,
+    ]);
+    expect(projectedMessage?.parts.map((part) =>
+      part.type === "text" ? part.text : part.type,
+    )).toEqual([
+      "visible",
+      "continued-1",
+      "continued-2",
+      "extension",
+      "continued-3",
+    ]);
+  });
+
+});

package/src/features/chat/features/message/utils/__tests__/chat-message-timeline-continuation-compaction.utils.test.ts

@@ -0,0 +1,167 @@
+import { describe, expect, it } from "vitest";
+import {
+  NCP_INTERNAL_VISIBILITY_METADATA_KEY,
+  type NcpMessage,
+} from "@nextclaw/ncp";
+import { CHAT_CONTINUATION_TARGET_MESSAGE_METADATA_KEY } from "@nextclaw/shared";
+import {
+  buildChatMessageTimelineItems,
+  projectVisibleChatMessages,
+} from "@/features/chat/features/message/utils/chat-message-timeline.utils";
+
+const visibleMessage = {
+  id: "assistant-visible",
+  sessionId: "session-1",
+  role: "assistant",
+  status: "final",
+  timestamp: "2026-08-07T00:00:00.000Z",
+  parts: [{ type: "text", text: "visible" }],
+} satisfies NcpMessage;
+
+function createContinuationPrompt(id: string, targetId: string): NcpMessage {
+  return {
+    ...visibleMessage,
+    id,
+    role: "user",
+    parts: [],
+    metadata: {
+      [NCP_INTERNAL_VISIBILITY_METADATA_KEY]: "hidden",
+      [CHAT_CONTINUATION_TARGET_MESSAGE_METADATA_KEY]: targetId,
+    },
+  };
+}
+
+function createCompactionMessage(params: {
+  assistantId?: string;
+  coveredPartCount?: number;
+  id: string;
+  phase: "pre-run" | "mid-run";
+  status?: "compressing" | "compressed";
+}): NcpMessage {
+  const {
+    assistantId,
+    coveredPartCount,
+    id,
+    phase,
+    status = "compressed",
+  } = params;
+  return {
+    ...visibleMessage,
+    id,
+    role: "service",
+    parts: [],
+    metadata: {
+      nextclaw_timeline_kind: "context_compaction",
+      checkpoint: {
+        id: `checkpoint-${id}`,
+        status,
+        phase,
+        continuationMessageId: assistantId,
+        continuationMessageCoveredPartCount: coveredPartCount,
+        summary: status === "compressing" ? "" : "Compressed context",
+        coveredMessageCount: 1,
+        coveredSessionMessageCount: 1,
+        originalEstimatedTokens: 34_000,
+        projectedEstimatedTokens: 26_000,
+        createdAt: "2026-08-07T00:00:50.000Z",
+        updatedAt: "2026-08-07T00:01:00.000Z",
+      },
+    },
+  };
+}
+
+describe("continuation compaction timeline projection", () => {
+  it("keeps legacy pre-run compaction inline before its assistant exists", () => {
+    const continuationPrompt = createContinuationPrompt(
+      "continue-pending",
+      visibleMessage.id,
+    );
+    const preRun = createCompactionMessage({
+      id: "context-compaction-pre-run-pending",
+      phase: "pre-run",
+      status: "compressing",
+    });
+    const rawMessages = [visibleMessage, continuationPrompt, preRun];
+
+    expect(projectVisibleChatMessages(rawMessages)[0]?.parts.map((part) =>
+      part.type === "extension" ? (part.data as { id: string }).id : part.type,
+    )).toEqual(["text", preRun.id]);
+    expect(buildChatMessageTimelineItems({
+      rawMessages,
+      messages: [{ id: visibleMessage.id } as never],
+    }).map((item) => item.kind)).toEqual(["message"]);
+  });
+
+  it("preserves explicit pre-run and mid-run boundaries across continuations", () => {
+    const firstAssistant: NcpMessage = {
+      ...visibleMessage,
+      id: "assistant-continuation-1",
+      parts: [
+        { type: "text", text: "continued-1" },
+        { type: "text", text: "continued-2" },
+      ],
+    };
+    const secondAssistant: NcpMessage = {
+      ...visibleMessage,
+      id: "assistant-continuation-2",
+      parts: [{ type: "text", text: "continued-3" }],
+    };
+    const firstPreRun = createCompactionMessage({
+      assistantId: visibleMessage.id,
+      coveredPartCount: visibleMessage.parts.length,
+      id: "pre-run-1",
+      phase: "pre-run",
+    });
+    const secondPreRun = createCompactionMessage({
+      assistantId: firstAssistant.id,
+      coveredPartCount: firstAssistant.parts.length,
+      id: "pre-run-2",
+      phase: "pre-run",
+    });
+    const firstMidRun = createCompactionMessage({
+      assistantId: firstAssistant.id,
+      coveredPartCount: 1,
+      id: "mid-run-1",
+      phase: "mid-run",
+    });
+    const secondMidRun = createCompactionMessage({
+      assistantId: secondAssistant.id,
+      coveredPartCount: 1,
+      id: "mid-run-2",
+      phase: "mid-run",
+    });
+    const rawMessages = [
+      visibleMessage,
+      createContinuationPrompt("continue-1", visibleMessage.id),
+      firstPreRun,
+      firstAssistant,
+      firstMidRun,
+      createContinuationPrompt("continue-2", firstAssistant.id),
+      secondPreRun,
+      secondAssistant,
+      secondMidRun,
+    ];
+
+    const [projectedMessage] = projectVisibleChatMessages(rawMessages);
+    expect(projectedMessage?.parts.map((part) =>
+      part.type === "extension"
+        ? (part.data as { id: string }).id
+        : part.type === "text"
+          ? part.text
+          : part.type,
+    )).toEqual([
+      "visible",
+      firstPreRun.id,
+      "continued-1",
+      firstMidRun.id,
+      "continued-2",
+      secondPreRun.id,
+      "continued-3",
+      secondMidRun.id,
+    ]);
+    expect(buildChatMessageTimelineItems({
+      rawMessages,
+      messages: [{ id: visibleMessage.id } as never],
+    }).map((item) => item.kind)).toEqual(["message"]);
+  });
+});