@nextclaw/ui 0.15.14 → 0.15.16

package/src/features/chat/features/conversation/utils/session-queued-input.utils.ts

@@ -0,0 +1,134 @@
+import {
+  createChatComposerTextNode,
+  createChatComposerTokenNode,
+  normalizeChatComposerNodes,
+  type ChatComposerNode,
+} from '@nextclaw/agent-chat-ui';
+import type { UiNcpSessionQueuedInputView } from '@nextclaw/client-sdk';
+import type { NcpDraftAttachment } from '@nextclaw/ncp-react';
+
+import {
+  readInlineTokensFromMetadata,
+  resolveInlineTokensForText,
+  type ChatInlineTokenSource,
+} from '@/features/chat/features/input/utils/chat-inline-token.utils';
+import { deriveChatComposerDraft } from '@/features/chat/features/input/utils/chat-composer-state.utils';
+import { normalizeRequestedSkills } from '@/features/chat/features/runtime/utils/chat-runtime.utils';
+import type { SessionConversationComposerState } from '@/features/chat/features/conversation/hooks/use-session-conversation-input-state';
+
+export type SessionQueuedInputComposerSnapshot = SessionConversationComposerState & {
+  readonly attachments: readonly NcpDraftAttachment[];
+};
+
+function buildTextNodes(
+  text: string,
+  inlineTokens: readonly ChatInlineTokenSource[],
+): ChatComposerNode[] {
+  const nodes: ChatComposerNode[] = [];
+  let offset = 0;
+  while (offset < text.length) {
+    const nextToken = inlineTokens
+      .flatMap((token) => {
+        const index = text.indexOf(token.rawText, offset);
+        return index < 0 ? [] : [{ index, token }];
+      })
+      .sort((left, right) => left.index - right.index || right.token.rawText.length - left.token.rawText.length)[0];
+    if (!nextToken) {
+      nodes.push(createChatComposerTextNode(text.slice(offset)));
+      return nodes;
+    }
+    if (nextToken.index > offset) {
+      nodes.push(createChatComposerTextNode(text.slice(offset, nextToken.index)));
+    }
+    nodes.push(createChatComposerTokenNode({
+      tokenKind: nextToken.token.kind,
+      tokenKey: "ref" in nextToken.token ? nextToken.token.ref : nextToken.token.key,
+      label: nextToken.token.label,
+    }));
+    offset = nextToken.index + nextToken.token.rawText.length;
+  }
+  return nodes;
+}
+
+function readInputMetadata(input: UiNcpSessionQueuedInputView): Record<string, unknown> {
+  return {
+    ...input.metadata,
+    ...input.message.metadata,
+  };
+}
+
+function readRequestedSkills(input: UiNcpSessionQueuedInputView): string[] {
+  const raw = readInputMetadata(input).requested_skill_refs;
+  return normalizeRequestedSkills(
+    Array.isArray(raw) ? raw.filter((value): value is string => typeof value === 'string') : undefined,
+  );
+}
+
+export function buildSessionQueuedInputPreview(input: UiNcpSessionQueuedInputView): string {
+  const inlineTokens = readInlineTokensFromMetadata(readInputMetadata(input));
+  const text = input.message.parts.flatMap((part) =>
+    part.type === 'text' || part.type === 'rich-text' || part.type === 'reasoning'
+      ? [part.text]
+      : [],
+  ).join(' ');
+  const plainText = inlineTokens.reduce(
+    (value, token) => value.split(token.rawText).join(''),
+    text,
+  ).replace(/\s+/g, ' ').trim();
+  if (plainText) {
+    return plainText;
+  }
+  return input.message.parts.flatMap((part) => part.type === 'file' && part.name ? [part.name] : []).join(', ');
+}
+
+export function buildSessionQueuedInputComposerSnapshot(
+  input: UiNcpSessionQueuedInputView,
+  availableSkills: readonly { ref: string; name: string }[],
+): SessionQueuedInputComposerSnapshot {
+  const nodes: ChatComposerNode[] = [];
+  const attachments: NcpDraftAttachment[] = [];
+  const metadataTokens = readInlineTokensFromMetadata(readInputMetadata(input));
+
+  input.message.parts.forEach((part, index) => {
+    if (part.type === 'text' || part.type === 'rich-text' || part.type === 'reasoning') {
+      nodes.push(...buildTextNodes(
+        part.text,
+        resolveInlineTokensForText(part.text, metadataTokens),
+      ));
+      return;
+    }
+    if (part.type !== 'file') {
+      return;
+    }
+    const id = `queued-attachment-${input.id}-${index}`;
+    const attachment: NcpDraftAttachment = {
+      id,
+      name: part.name ?? 'attachment',
+      mimeType: part.mimeType ?? 'application/octet-stream',
+      sizeBytes: part.sizeBytes ?? 0,
+      assetUri: part.assetUri,
+      url: part.url,
+      contentBase64: part.contentBase64,
+    };
+    attachments.push(attachment);
+    nodes.push(createChatComposerTokenNode({
+      tokenKind: 'file',
+      tokenKey: id,
+      label: attachment.name,
+    }));
+  });
+
+  const normalizedNodes = normalizeChatComposerNodes(nodes);
+  const selectedSkills = readRequestedSkills(input);
+  const skillNameByRef = new Map(availableSkills.map(({ ref, name }) => [ref, name]));
+  return {
+    text: deriveChatComposerDraft(normalizedNodes),
+    nodes: normalizedNodes,
+    selectedSkills,
+    skillRecords: selectedSkills.map((ref) => ({
+      ref,
+      name: skillNameByRef.get(ref) ?? ref,
+    })),
+    attachments,
+  };
+}

package/src/features/chat/features/input/utils/__tests__/chat-composer-state.utils.test.ts

@@ -12,10 +12,10 @@ describe('deriveNcpMessagePartsFromComposer', () => {
           label: 'one.png'
         }),
         createChatComposerTextNode(' between '),
-        createChatComposerTokenNode({
-          tokenKind: 'skill',
-          tokenKey: 'web-search',
-          label: 'Web Search'
+          createChatComposerTokenNode({
+            tokenKind: 'skill',
+            tokenKey: 'workspace:/tmp/workspace/skills/web-search',
+            label: 'Web Search'
         }),
         createChatComposerTextNode('after'),
         createChatComposerTokenNode({
@@ -56,7 +56,7 @@ describe('deriveNcpMessagePartsFromComposer', () => {
       },
       {
         type: 'text',
-        text: ' between $web-searchafter'
+        text: ' between $Web Searchafter'
       },
       {
         type: 'file',

package/src/features/chat/features/input/utils/__tests__/chat-inline-token.utils.test.ts

@@ -11,72 +11,151 @@ import {
 describe('chat-inline-token utils', () => {
   it('builds ordered inline skill tokens from composer nodes', () => {
     expect(
-      buildInlineTokensFromComposer([
-        createChatComposerTextNode('before '),
-        createChatComposerTokenNode({
-          tokenKind: 'skill',
-          tokenKey: 'weather',
-          label: 'Weather'
-        }),
-        createChatComposerTokenNode({
-          tokenKind: 'skill',
-          tokenKey: 'docs',
-          label: 'Docs'
-        })
-      ])
+      buildInlineTokensFromComposer(
+        [
+          createChatComposerTextNode('before '),
+          createChatComposerTokenNode({
+            tokenKind: 'skill',
+            tokenKey: 'workspace:/skills/weather',
+            label: 'weather'
+          }),
+          createChatComposerTokenNode({
+            tokenKind: 'skill',
+            tokenKey: 'global:/skills/docs',
+            label: 'docs'
+          })
+        ],
+        [
+          {
+            ref: 'workspace:/skills/weather',
+            name: 'weather',
+            source: 'workspace',
+            path: '/skills/weather/SKILL.md',
+          },
+          {
+            ref: 'global:/skills/docs',
+            name: 'docs',
+            source: 'global',
+            path: '/skills/docs/SKILL.md',
+          },
+        ],
+      )
     ).toEqual([
       {
         kind: 'skill',
-        key: 'weather',
-        label: 'Weather',
+        ref: 'workspace:/skills/weather',
+        name: 'weather',
+        source: 'workspace',
+        path: '/skills/weather/SKILL.md',
+        label: 'weather',
         rawText: '$weather'
       },
       {
         kind: 'skill',
-        key: 'docs',
-        label: 'Docs',
+        ref: 'global:/skills/docs',
+        name: 'docs',
+        source: 'global',
+        path: '/skills/docs/SKILL.md',
+        label: 'docs',
         rawText: '$docs'
       }
     ]);
   });
 
-  it('reads generic inline token metadata safely', () => {
+  it('reads versioned inline skill metadata without parsing its ref', () => {
     expect(
       readInlineTokensFromMetadata({
-        [CHAT_INLINE_TOKENS_METADATA_KEY]: [
-          {
-            kind: 'skill',
-            key: 'weather',
-            label: 'Weather',
-            rawText: '$weather'
-          }
-        ]
+        [CHAT_INLINE_TOKENS_METADATA_KEY]: {
+          schemaVersion: 2,
+          items: [
+            {
+              kind: 'skill',
+              ref: 'workspace:/skills/weather',
+              name: 'weather',
+              source: 'workspace',
+              path: '/skills/weather/SKILL.md',
+              label: 'weather',
+              rawText: '$weather'
+            }
+          ]
+        }
       })
     ).toEqual([
       {
         kind: 'skill',
-        key: 'weather',
-        label: 'Weather',
+        ref: 'workspace:/skills/weather',
+        name: 'weather',
+        source: 'workspace',
+        path: '/skills/weather/SKILL.md',
+        label: 'weather',
         rawText: '$weather'
       }
     ]);
   });
 
+  it('normalizes persisted v1 skill keys only at the metadata boundary', () => {
+    expect(readInlineTokensFromMetadata({
+      [CHAT_INLINE_TOKENS_METADATA_KEY]: [
+        {
+          kind: 'skill',
+          key: 'workspace:/skills/weather',
+          label: 'weather',
+          rawText: '$workspace:/skills/weather',
+        },
+      ],
+    })).toEqual([
+      {
+        kind: 'skill',
+        ref: 'workspace:/skills/weather',
+        name: 'weather',
+        source: null,
+        path: null,
+        label: 'weather',
+        rawText: '$workspace:/skills/weather',
+      },
+    ]);
+  });
+
+  it('preserves every skill source as an explicit field', () => {
+    const sources = ['builtin', 'global', 'project', 'workspace'] as const;
+    const tokens = buildInlineTokensFromComposer(
+      sources.map((source) => createChatComposerTokenNode({
+        tokenKind: 'skill',
+        tokenKey: `${source}:/skills/${source}`,
+        label: source,
+      })),
+      sources.map((source) => ({
+        ref: `${source}:/skills/${source}`,
+        name: source,
+        source,
+        path: `/skills/${source}/SKILL.md`,
+      })),
+    );
+
+    expect(tokens.map((token) => token.kind === 'skill' ? token.source : null)).toEqual(sources);
+  });
+
   it('merges metadata tokens with pure text protocol tokens', () => {
     expect(
       resolveInlineTokensForText('please use $weather and @panel-app:task-board', [
         {
           kind: 'skill',
-          key: 'weather',
-          label: 'Weather',
+          ref: 'workspace:/skills/weather',
+          name: 'weather',
+          source: 'workspace',
+          path: '/skills/weather/SKILL.md',
+          label: 'weather',
           rawText: '$weather'
         }
       ])
     ).toEqual([
       {
         kind: 'skill',
-        key: 'weather',
-        label: 'Weather',
+        ref: 'workspace:/skills/weather',
+        name: 'weather',
+        source: 'workspace',
+        path: '/skills/weather/SKILL.md',
+        label: 'weather',
         rawText: '$weather'
       },
       {
@@ -87,7 +166,9 @@ describe('chat-inline-token utils', () => {
       }
     ]);
   });
+});
 
+describe('chat inline token workspace references', () => {
   it('builds inline panel app tokens from pure text protocol', () => {
     expect(buildInlineTokensFromTextProtocol('review @panel-app:task-board now')).toEqual([
       {

package/src/features/chat/features/input/utils/chat-composer-token-protocol.utils.ts

@@ -9,12 +9,13 @@ const CHAT_WORKSPACE_FILE_TOKEN_PREFIX = '@file:';
 const CHAT_WORKSPACE_DIRECTORY_TOKEN_PREFIX = '@folder:';
 
 export function serializeChatComposerTokenText(params: {
+  label?: string;
   tokenKey: string;
   tokenKind: string;
 }): string | null {
-  const { tokenKey, tokenKind } = params;
+  const { label, tokenKey, tokenKind } = params;
   if (tokenKind === 'skill') {
-    return `${CHAT_SKILL_TOKEN_PREFIX}${tokenKey}`;
+    return `${CHAT_SKILL_TOKEN_PREFIX}${label?.trim() || tokenKey}`;
   }
   if (tokenKind === 'panel_app') {
     return `${CHAT_PANEL_APP_TOKEN_PREFIX}${tokenKey}`;

package/src/features/chat/features/input/utils/chat-inline-token.utils.ts

@@ -1,9 +1,12 @@
 import type { ChatComposerNode } from '@nextclaw/agent-chat-ui';
 import {
   CHAT_INLINE_TOKENS_METADATA_KEY,
+  CHAT_INLINE_TOKENS_SCHEMA_VERSION,
   CHAT_WORKSPACE_DIRECTORY_TOKEN_KIND,
   CHAT_WORKSPACE_FILE_TOKEN_KIND,
   type ChatInlineTokenMetadata,
+  type ChatInlineTokensMetadata,
+  type ChatSkillSource,
 } from '@nextclaw/shared';
 import { serializeChatComposerTokenText } from './chat-composer-token-protocol.utils';
 
@@ -13,7 +16,29 @@ const CHAT_PANEL_APP_TOKEN_PATTERN = /@panel-app:([A-Za-z0-9_-]+)/g;
 const CHAT_WORKSPACE_FILE_TOKEN_PATTERN = /@file:([^\s]+)/g;
 const CHAT_WORKSPACE_DIRECTORY_TOKEN_PATTERN = /@folder:([^\s]+)/g;
 
-export type ChatInlineTokenSource = ChatInlineTokenMetadata;
+export type ChatSkillReferenceSnapshot = {
+  ref: string;
+  name: string;
+  source: ChatSkillSource;
+  path: string;
+};
+
+export type ChatInlineTokenSource =
+  | {
+      kind: 'skill';
+      ref: string;
+      name: string;
+      source: ChatSkillSource | null;
+      path: string | null;
+      label: string;
+      rawText: string;
+    }
+  | {
+      kind: string;
+      key: string;
+      label: string;
+      rawText: string;
+    };
 
 export function resolveWorkspaceReferencePath(params: {
   projectRoot: string | null | undefined;
@@ -44,11 +69,12 @@ function readOptionalString(value: unknown): string | null {
   return trimmed.length > 0 ? trimmed : null;
 }
 
-function dedupeInlineTokens(tokens: readonly ChatInlineTokenSource[]): ChatInlineTokenSource[] {
+function dedupeInlineTokens<T extends ChatInlineTokenSource>(tokens: readonly T[]): T[] {
   const seen = new Set<string>();
-  const output: ChatInlineTokenSource[] = [];
+  const output: T[] = [];
   for (const token of tokens) {
-    const dedupeKey = `${token.kind}:${token.key}:${token.rawText}`;
+    const identity = 'ref' in token ? token.ref : token.key;
+    const dedupeKey = `${token.kind}:${identity}:${token.rawText}`;
     if (seen.has(dedupeKey)) {
       continue;
     }
@@ -58,8 +84,12 @@ function dedupeInlineTokens(tokens: readonly ChatInlineTokenSource[]): ChatInlin
   return output;
 }
 
-export function buildInlineTokensFromComposer(nodes: readonly ChatComposerNode[]): ChatInlineTokenSource[] {
-  const tokens: ChatInlineTokenSource[] = [];
+export function buildInlineTokensFromComposer(
+  nodes: readonly ChatComposerNode[],
+  skillRecords: readonly ChatSkillReferenceSnapshot[] = [],
+): ChatInlineTokenMetadata[] {
+  const skillByRef = new Map(skillRecords.map((record) => [record.ref, record]));
+  const tokens: ChatInlineTokenMetadata[] = [];
   for (const node of nodes) {
     if (node.type !== 'token') {
       continue;
@@ -75,8 +105,27 @@ export function buildInlineTokensFromComposer(nodes: readonly ChatComposerNode[]
     if (!rawText) {
       continue;
     }
+    if (node.tokenKind === 'skill') {
+      const skill = skillByRef.get(node.tokenKey);
+      if (!skill?.path.trim()) {
+        continue;
+      }
+      tokens.push({
+        kind: 'skill',
+        ref: skill.ref,
+        name: skill.name,
+        source: skill.source,
+        path: skill.path,
+        label: node.label,
+        rawText,
+      });
+      continue;
+    }
+    const workspaceKind = node.tokenKind === CHAT_WORKSPACE_FILE_TOKEN_KIND
+      ? CHAT_WORKSPACE_FILE_TOKEN_KIND
+      : CHAT_WORKSPACE_DIRECTORY_TOKEN_KIND;
     tokens.push({
-      kind: node.tokenKind,
+      kind: workspaceKind,
       key: node.tokenKey,
       label: node.label,
       rawText,
@@ -152,28 +201,85 @@ export function readInlineTokensFromMetadata(
   metadata: Record<string, unknown> | undefined
 ): ChatInlineTokenSource[] {
   const raw = metadata?.[CHAT_INLINE_TOKENS_METADATA_KEY];
-  if (!Array.isArray(raw)) {
+  if (Array.isArray(raw)) {
+    return readLegacyInlineTokens(raw);
+  }
+  if (
+    !isRecord(raw) ||
+    raw.schemaVersion !== CHAT_INLINE_TOKENS_SCHEMA_VERSION ||
+    !Array.isArray(raw.items)
+  ) {
     return [];
   }
 
   const tokens: ChatInlineTokenSource[] = [];
-  for (const entry of raw) {
+  for (const entry of raw.items) {
     if (!isRecord(entry)) {
       continue;
     }
     const kind = readOptionalString(entry.kind);
-    const key = readOptionalString(entry.key);
     const rawText = readOptionalString(entry.rawText);
-    if (!kind || !key || !rawText) {
+    const label = readOptionalString(entry.label);
+    if (!kind || !label || !rawText) {
+      continue;
+    }
+    if (kind === 'skill') {
+      const ref = readOptionalString(entry.ref);
+      const name = readOptionalString(entry.name);
+      const path = readOptionalString(entry.path);
+      const source = readSkillSource(entry.source);
+      if (!ref || !name || !path || !source) {
+        continue;
+      }
+      tokens.push({ kind, ref, name, source, path, label, rawText });
+      continue;
+    }
+    const key = readOptionalString(entry.key);
+    if (!key) {
       continue;
     }
     tokens.push({
       kind,
       key,
       rawText,
-      label: readOptionalString(entry.label) ?? key
+      label,
     });
   }
 
   return dedupeInlineTokens(tokens);
 }
+
+function readSkillSource(value: unknown): ChatSkillSource | null {
+  return value === 'builtin' || value === 'global' || value === 'project' || value === 'workspace'
+    ? value
+    : null;
+}
+
+function readLegacyInlineTokens(entries: readonly unknown[]): ChatInlineTokenSource[] {
+  const tokens: ChatInlineTokenSource[] = [];
+  for (const entry of entries) {
+    if (!isRecord(entry)) {
+      continue;
+    }
+    const kind = readOptionalString(entry.kind);
+    const key = readOptionalString(entry.key);
+    const rawText = readOptionalString(entry.rawText);
+    if (!kind || !key || !rawText) {
+      continue;
+    }
+    const label = readOptionalString(entry.label) ?? key;
+    tokens.push(kind === 'skill'
+      ? { kind, ref: key, name: label, source: null, path: null, label, rawText }
+      : { kind, key, label, rawText });
+  }
+  return dedupeInlineTokens(tokens);
+}
+
+export function createInlineTokensMetadata(
+  items: ChatInlineTokenMetadata[],
+): ChatInlineTokensMetadata {
+  return {
+    schemaVersion: CHAT_INLINE_TOKENS_SCHEMA_VERSION,
+    items,
+  };
+}