flare-chat-core 0.2.1 → 0.2.2

package/src/app/core-chat-entry/attachmentSendRefs.js

@@ -0,0 +1,154 @@
+function normalizeSourceId(item) {
+  if (typeof item === 'string') {
+    return String(item).trim();
+  }
+  if (item && typeof item === 'object' && !Array.isArray(item)) {
+    return String(item.source_id || item.id || '').trim();
+  }
+  return '';
+}
+
+export function mergeSourceReferenceLists(...lists) {
+  const refs = [];
+  const seen = new Set();
+  lists.forEach((list) => {
+    if (!Array.isArray(list)) {
+      return;
+    }
+    list.forEach((item) => {
+      const sourceId = normalizeSourceId(item);
+      if (!sourceId || seen.has(sourceId)) {
+        return;
+      }
+      seen.add(sourceId);
+      refs.push({ source_id: sourceId });
+    });
+  });
+  return refs;
+}
+
+export function collectSourceIdStrings(...lists) {
+  const ids = [];
+  const seen = new Set();
+  lists.forEach((list) => {
+    if (!Array.isArray(list)) {
+      return;
+    }
+    list.forEach((item) => {
+      const sourceId = normalizeSourceId(item);
+      if (!sourceId || seen.has(sourceId)) {
+        return;
+      }
+      seen.add(sourceId);
+      ids.push(sourceId);
+    });
+  });
+  return ids;
+}
+
+function normalizeAttachmentStatus(item) {
+  return String(item?.status || '').trim().toLowerCase();
+}
+
+export function collectReadyAttachmentRefs(fileList = []) {
+  if (!Array.isArray(fileList)) {
+    return [];
+  }
+  const readyRefs = fileList.filter((item) => {
+    const sourceId = normalizeSourceId(item);
+    if (!sourceId) {
+      return false;
+    }
+    return normalizeAttachmentStatus(item) === 'ready';
+  });
+  return mergeSourceReferenceLists(readyRefs);
+}
+
+export function hasNonReadyComposerAttachments(fileList = []) {
+  if (!Array.isArray(fileList)) {
+    return false;
+  }
+  return fileList.some((item) => {
+    const sourceId = normalizeSourceId(item);
+    const status = normalizeAttachmentStatus(item);
+    return Boolean(!sourceId || status !== 'ready');
+  });
+}
+
+function buildAttachmentSnapshot(fileList = []) {
+  if (!Array.isArray(fileList)) {
+    return [];
+  }
+  return fileList.map((item) => ({ ...item }));
+}
+
+function resolveUploadableFile(item) {
+  if (!item || typeof item !== 'object' || Array.isArray(item)) {
+    return null;
+  }
+  const sourceId = String(item.source_id || '').trim();
+  if (sourceId) {
+    return null;
+  }
+  const status = String(item.status || '').trim().toLowerCase();
+  if (status === 'failed') {
+    return null;
+  }
+  return item.originFileObj || null;
+}
+
+export async function prepareComposerAttachmentSendRefs({
+  fileList = [],
+  uploadSourceFile,
+  projectId = '',
+  sessionId = '',
+} = {}) {
+  const attachedSessionFilesSnapshot = buildAttachmentSnapshot(fileList);
+  const resolvedProjectId = String(projectId || '').trim();
+  const canUpload = typeof uploadSourceFile === 'function' && Boolean(resolvedProjectId);
+
+  if (canUpload) {
+    await Promise.all(attachedSessionFilesSnapshot.map(async (attachment, index) => {
+      const uploadableFile = resolveUploadableFile(attachment);
+      if (!uploadableFile) {
+        return;
+      }
+      try {
+        const uploaded = await uploadSourceFile({
+          file: uploadableFile,
+          filename: attachment?.name || attachment?.filename || uploadableFile?.name || 'upload.bin',
+          project_id: resolvedProjectId,
+          session_id: String(sessionId || '').trim() || null,
+        });
+        const sourceId = String(uploaded?.source_id || uploaded?.id || '').trim();
+        if (!sourceId) {
+          attachedSessionFilesSnapshot[index] = {
+            ...attachment,
+            status: 'failed',
+            error_message: '上传成功但未返回 source_id',
+          };
+          return;
+        }
+        attachedSessionFilesSnapshot[index] = {
+          ...attachment,
+          ...uploaded,
+          source_id: sourceId,
+          status: String(uploaded?.status || attachment?.status || 'ready'),
+          error_message: String(uploaded?.error_message || ''),
+        };
+      } catch (error) {
+        attachedSessionFilesSnapshot[index] = {
+          ...attachment,
+          status: 'failed',
+          error_message: String(error?.message || error || '上传失败'),
+        };
+      }
+    }));
+  }
+
+  const refs = mergeSourceReferenceLists(attachedSessionFilesSnapshot.filter((item) => String(item?.status || '').trim().toLowerCase() !== 'failed'));
+  return {
+    attachedSessionFilesSnapshot,
+    refs,
+  };
+}

package/src/app/core-chat-entry/attachmentSendRefs.test.mjs

@@ -0,0 +1,101 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  collectSourceIdStrings,
+  collectReadyAttachmentRefs,
+  hasNonReadyComposerAttachments,
+  mergeSourceReferenceLists,
+  prepareComposerAttachmentSendRefs,
+} from './attachmentSendRefs.js';
+
+test('mergeSourceReferenceLists keeps unique refs from strings and objects', () => {
+  const refs = mergeSourceReferenceLists(
+    ['src-1', '', 'src-1'],
+    [{ source_id: 'src-2' }, { id: 'src-3' }, null],
+  );
+  assert.deepEqual(refs, [
+    { source_id: 'src-1' },
+    { source_id: 'src-2' },
+    { source_id: 'src-3' },
+  ]);
+});
+
+test('collectSourceIdStrings keeps unique source ids from mixed refs', () => {
+  const ids = collectSourceIdStrings(
+    ['src-1', { source_id: 'src-2' }, { id: 'src-3' }],
+    [{ source_id: 'src-1' }, '', null, { source_id: '' }],
+  );
+  assert.deepEqual(ids, ['src-1', 'src-2', 'src-3']);
+});
+
+test('prepareComposerAttachmentSendRefs uploads pending files and skips failed refs', async () => {
+  const uploaded = [];
+  const payload = await prepareComposerAttachmentSendRefs({
+    fileList: [
+      {
+        uid: 'f1',
+        name: 'a.docx',
+        originFileObj: { name: 'a.docx' },
+        status: 'ready',
+      },
+      {
+        uid: 'f2',
+        name: 'b.pdf',
+        originFileObj: { name: 'b.pdf' },
+        status: 'failed',
+      },
+      {
+        uid: 'f3',
+        name: 'c.txt',
+        source_id: 'src-existing',
+        originFileObj: { name: 'c.txt' },
+        status: 'ready',
+      },
+    ],
+    uploadSourceFile: async (input) => {
+      uploaded.push(input.filename);
+      return { source_id: 'src-uploaded' };
+    },
+    projectId: 'project-1',
+    sessionId: 'session-1',
+  });
+
+  assert.deepEqual(uploaded, ['a.docx']);
+  assert.deepEqual(payload.refs, [
+    { source_id: 'src-uploaded' },
+    { source_id: 'src-existing' },
+  ]);
+  assert.equal(payload.attachedSessionFilesSnapshot[0].source_id, 'src-uploaded');
+  assert.equal(payload.attachedSessionFilesSnapshot[1].status, 'failed');
+});
+
+test('collectReadyAttachmentRefs includes only ready source_id entries', () => {
+  const refs = collectReadyAttachmentRefs([
+    { source_id: 'src-ready-1', status: 'ready' },
+    { source_id: 'src-uploaded', status: 'uploaded' },
+    { source_id: 'src-ready-2', status: 'ready' },
+    { source_id: 'src-failed', status: 'failed' },
+    { source_id: '', status: 'ready' },
+  ]);
+
+  assert.deepEqual(refs, [
+    { source_id: 'src-ready-1' },
+    { source_id: 'src-ready-2' },
+  ]);
+});
+
+test('hasNonReadyComposerAttachments blocks when any file is not ready', () => {
+  assert.equal(hasNonReadyComposerAttachments([
+    { source_id: 'src-1', status: 'ready' },
+    { source_id: 'src-2', status: 'ready' },
+  ]), false);
+
+  assert.equal(hasNonReadyComposerAttachments([
+    { source_id: 'src-1', status: 'ready' },
+    { source_id: 'src-2', status: 'indexing' },
+  ]), true);
+
+  assert.equal(hasNonReadyComposerAttachments([
+    { source_id: '', status: 'ready' },
+  ]), true);
+});

package/src/app/core-chat-entry/composerActionRouter.js

@@ -0,0 +1,26 @@
+function toText(value) {
+  return String(value || '').trim();
+}
+
+export function buildComposerDraftRoundKey({
+  activeSessionId,
+  currentInput,
+}) {
+  const sessionPart = toText(activeSessionId) || 'draft';
+  const inputPart = toText(currentInput);
+  return `${sessionPart}:${inputPart}`;
+}
+
+export function resolveComposerActionIntent(choice) {
+  const actionPayload = choice?.action && typeof choice.action === 'object'
+    ? choice.action
+    : null;
+  const actionKey = toText(actionPayload?.action_key);
+  if (actionKey === 'open_sourcing') {
+    return { kind: 'open_sourcing' };
+  }
+  if (actionKey === 'dismiss_sourcing_once') {
+    return { kind: 'dismiss_sourcing_once' };
+  }
+  return { kind: 'noop' };
+}

package/src/app/core-chat-entry/constants.js

@@ -0,0 +1,108 @@
+export const WORKSPACE_CONTENT_MAX_WIDTH = 980;
+
+export const RESOLVED_UI_LABELS = {
+  tab_chats: '会话',
+  tab_sources: '资料',
+  edit_project_button: '编辑',
+  sidebar_operations_title: '常规操作',
+  project_select_hint: '请从左侧项目列表选择一个项目。',
+  project_create_hint: '先创建一个项目，然后开始会话。',
+  project_list_empty: '还没有项目，点击“创建项目”开始。',
+  new_project_button: '创建项目',
+  new_session_button: '新会话',
+  project_sort_by_name: '按名称',
+  project_sort_by_updated: '按最近更新',
+  empty_state_title: '欢迎使用 FLARE',
+  empty_state_description: '开始一个新对话。',
+  scenario_expand_label: '查看更多',
+  scenario_collapse_label: '收起',
+  composer_attach_label: '上传文件',
+  composer_hint: '描述你的目标、背景或约束，系统会先帮你判断下一步。',
+  canvas_workspace_title: '需求梳理工作区',
+  sources_add_button: '添加资料',
+  sources_loading: '资料加载中...',
+  sources_empty_description: '上传到项目资料池后，后续该项目下的对话和分析都可以复用这些资料。',
+};
+
+export const STARTER_SCENARIOS = [
+  {
+    key: 'starter-1',
+    label: '帮我梳理一个需求',
+    description: '先补齐目标、约束和验收标准。',
+    prompt: '帮我梳理一个需求',
+  },
+  {
+    key: 'starter-2',
+    label: '帮我做方案对比',
+    description: '从关键维度对比候选方案。',
+    prompt: '帮我做方案对比',
+  },
+  {
+    key: 'starter-3',
+    label: '帮我整理执行计划',
+    description: '拆分阶段任务并明确里程碑。',
+    prompt: '帮我整理执行计划',
+  },
+];
+
+export const MODE_SWITCH_OPTIONS = [
+  { value: 'requirement_canvas', label: 'Plan 模式' },
+  { value: 'intelligent_sourcing', label: '寻源模式' },
+  { value: 'analysis_mode', label: '分析模式' },
+];
+
+export const MODE_SUGGESTION_TIP_RULES = [
+  {
+    id: 'analysis',
+    modeKey: 'analysis_mode',
+    label: '分析模式',
+    reason: '识别到分析或模板诉求，建议开启分析模式。',
+    actionText: '开始需求分析',
+    keywords: ['分析', '模板', '模版', '清单模板', '报告'],
+  },
+  {
+    id: 'sourcing',
+    modeKey: 'intelligent_sourcing',
+    label: '寻源模式',
+    reason: '识别到找供应商/检索诉求，建议开启寻源模式。',
+    actionText: '启用寻源模式',
+    keywords: ['找', '寻源', '搜索', '检索', '供应商', '比价'],
+  },
+  {
+    id: 'plan',
+    modeKey: 'requirement_canvas',
+    label: 'Plan 模式',
+    reason: '识别到需求规划/整理诉求，建议开启 Plan 模式。',
+    actionText: '开始需求梳理',
+    keywords: ['规划', '整理', '梳理', '需求', '采购', '收口'],
+  },
+];
+
+export const RESPONSE_STYLE_POLICY = {
+  friendlyPrefix: '好的，我们先把关键信息理清楚：',
+  questionReplyHint: '你可以直接回复序号或补充信息，我来继续整理。',
+};
+
+export function createWorkspaceStyle(themeTokens) {
+  return {
+    '--flare-accent': themeTokens.bubbleUserBg,
+    '--flare-accent-hover': themeTokens.surfaceBorderActive,
+    '--flare-focus-outline': themeTokens.focusOutline,
+    '--flare-font-body': themeTokens.fontFamilyBody,
+    '--flare-font-heading': themeTokens.fontFamilyHeading,
+    '--flare-hover-bg': themeTokens.surfaceBgActive,
+    '--flare-scrollbar-thumb': themeTokens.divider,
+    '--flare-surface-bg-active': themeTokens.surfaceBgActive,
+    '--flare-surface-border-active': themeTokens.surfaceBorderActive,
+    '--flare-text-primary': themeTokens.textPrimary,
+    '--flare-text-secondary': themeTokens.textSecondary,
+    background: themeTokens.appBg,
+    boxShadow: themeTokens.appShadow,
+    display: 'grid',
+    gridTemplateColumns: '300px minmax(0, 1fr)',
+    gridTemplateRows: 'minmax(0, 1fr)',
+    height: '100vh',
+    overflow: 'hidden',
+    position: 'relative',
+  };
+}

package/src/app/core-chat-entry/selectors.js

@@ -0,0 +1,28 @@
+function getSessionId(item) {
+  return String(item?.sessionId || item?.session_id || item?.id || '').trim();
+}
+
+export function selectActiveSession(sessions, activeSessionId) {
+  return sessions.find((item) => {
+    const sessionId = getSessionId(item);
+    return Boolean(sessionId && sessionId === activeSessionId);
+  }) || null;
+}
+
+export function selectProjectItems({
+  projectId,
+  projectDisplayName,
+  sessions,
+}) {
+  const sessionItems = Array.isArray(sessions) ? sessions : [];
+  if (sessionItems.length <= 0) {
+    return [];
+  }
+  return [{
+    key: 'local_demo_project',
+    project_id: projectId,
+    name: projectDisplayName,
+    updatedAt: sessionItems[0]?.updatedAt || sessionItems[0]?.updated_at || new Date().toISOString(),
+    createdAt: sessionItems[0]?.createdAt || sessionItems[0]?.created_at || new Date().toISOString(),
+  }];
+}

package/src/app/core-chat-entry/useAppActionErrorGuards.js

@@ -0,0 +1,68 @@
+import { useCallback, useMemo, useState } from 'react';
+
+function normalizeError(error, fallbackMessage) {
+  if (error instanceof Error) {
+    return error;
+  }
+  return new Error(String(error || fallbackMessage));
+}
+
+export function useAppActionErrorGuards({
+  blocked = false,
+  blockedError,
+  sessionListError = null,
+  composerError = null,
+  onCreateProject,
+  onCreateSession,
+  onSend,
+} = {}) {
+  const [actionError, setActionError] = useState(null);
+
+  const handleCreateProject = useCallback(async () => {
+    if (blocked) {
+      setActionError(blockedError);
+      return;
+    }
+    try {
+      setActionError(null);
+      await onCreateProject?.();
+    } catch (nextError) {
+      setActionError(normalizeError(nextError, '创建项目失败'));
+    }
+  }, [blocked, blockedError, onCreateProject]);
+
+  const handleCreateSession = useCallback(async () => {
+    if (blocked) {
+      setActionError(blockedError);
+      return;
+    }
+    try {
+      setActionError(null);
+      await onCreateSession?.();
+    } catch (nextError) {
+      setActionError(normalizeError(nextError, '创建会话失败'));
+    }
+  }, [blocked, blockedError, onCreateSession]);
+
+  const handleSend = useCallback(async (options = {}) => {
+    if (blocked) {
+      setActionError(blockedError);
+      return;
+    }
+    setActionError(null);
+    const sendResult = await onSend?.(options);
+    if (sendResult instanceof Error) {
+      setActionError(sendResult);
+    }
+    return sendResult;
+  }, [blocked, blockedError, onSend]);
+
+  return useMemo(() => ({
+    actionError,
+    handleCreateProject,
+    handleCreateSession,
+    handleSend,
+    sessionPaneError: actionError || sessionListError || null,
+    streamError: actionError || composerError || null,
+  }), [actionError, composerError, handleCreateProject, handleCreateSession, handleSend, sessionListError]);
+}

package/src/app/core-chat-entry/useChatCorePipelines.js

@@ -0,0 +1,110 @@
+import { useMemo } from 'react';
+import { useCoreChatApp } from '../../chat-core/app/useCoreChatApp.js';
+import { useAppStream } from '../../chat-core/app/useAppStream.js';
+import { createMockRuntime } from '../../chat-core/app/mockRuntime.js';
+import { createSessionMessageAPI } from '../../adapters/session-message-api.js';
+import { useRealApiReadinessGate } from './useRealApiReadinessGate.js';
+
+export function useChatCorePipelines({
+  functionType,
+  defaultSessionTitle,
+  projectId,
+  userId,
+  backendMode,
+  kernelBaseUrl,
+  apiBaseUrl,
+  apiToken,
+  sessionAPI,
+  messageAPI,
+}) {
+  const normalizedApiBaseUrl = String(apiBaseUrl || '').trim();
+  const runtime = useMemo(() => createMockRuntime({
+    defaultFunctionType: functionType,
+    defaultSessionTitle,
+  }), [defaultSessionTitle, functionType]);
+
+  const scope = useMemo(() => ({
+    projectId,
+    userId,
+  }), [projectId, userId]);
+
+  const listParams = useMemo(() => ({
+    status: 'active',
+    page: 1,
+    page_size: 20,
+    function_type: functionType,
+    project_id: projectId,
+  }), [functionType, projectId]);
+
+  const shouldUseRealAPI = backendMode === 'real' && !sessionAPI && !messageAPI;
+  const apiReadinessGate = useRealApiReadinessGate({
+    enabled: shouldUseRealAPI,
+    apiBaseUrl: normalizedApiBaseUrl,
+    apiToken,
+  });
+  const blockedApiError = useMemo(() => (
+    apiReadinessGate.error || new Error('API 不可用，请检查配置与服务状态')
+  ), [apiReadinessGate.error]);
+  const blockedSessionAPI = useMemo(() => ({
+    list: async () => ({ sessions: [] }),
+    get: async () => {
+      throw blockedApiError;
+    },
+    create: async () => {
+      throw blockedApiError;
+    },
+    update: async () => {
+      throw blockedApiError;
+    },
+  }), [blockedApiError]);
+  const blockedMessageAPI = useMemo(() => ({
+    list: async () => {
+      throw blockedApiError;
+    },
+  }), [blockedApiError]);
+  const realApi = useMemo(() => {
+    if (!shouldUseRealAPI || apiReadinessGate.blocked) {
+      return null;
+    }
+    return createSessionMessageAPI({
+      baseUrl: normalizedApiBaseUrl,
+      token: apiToken,
+    });
+  }, [apiReadinessGate.blocked, apiToken, normalizedApiBaseUrl, shouldUseRealAPI]);
+  const resolvedSessionAPI = sessionAPI
+    || realApi?.sessionAPI
+    || (shouldUseRealAPI ? blockedSessionAPI : runtime.sessionAPI);
+  const resolvedMessageAPI = messageAPI
+    || realApi?.messageAPI
+    || (shouldUseRealAPI ? blockedMessageAPI : runtime.messageAPI);
+  const useRuntimePersistence = !shouldUseRealAPI && !sessionAPI && !messageAPI;
+
+  const stream = useAppStream({
+    runtime,
+    backendMode,
+    apiBaseUrl: normalizedApiBaseUrl,
+    kernelBaseUrl,
+    scope,
+    persistExchange: useRuntimePersistence ? runtime.appendExchange : null,
+  });
+
+  const { viewModel } = useCoreChatApp({
+    sessionAPI: resolvedSessionAPI,
+    messageAPI: resolvedMessageAPI,
+    stream,
+    functionType,
+    defaultSessionTitle,
+    listParams,
+    createSessionPayload: {
+      project_id: projectId,
+      user_id: userId,
+    },
+  });
+
+  return {
+    apiReadinessGate,
+    blockedApiError,
+    realApi,
+    viewModel,
+  };
+}

package/src/app/core-chat-entry/useComposerModeSuggestion.js

@@ -0,0 +1,89 @@
+import { useMemo } from 'react';
+
+function normalizeText(value) {
+  return String(value || '').trim().toLowerCase();
+}
+
+function hasAnyKeyword(content, keywords = []) {
+  return keywords.some((keyword) => content.includes(String(keyword || '').trim().toLowerCase()));
+}
+
+function buildSuggestionFromInput({
+  inputValue,
+  activeModeKey,
+  tipRules = [],
+  contextFlags = {},
+}) {
+  const resolvedModeKey = String(activeModeKey || '').trim();
+  if (resolvedModeKey !== 'auto') {
+    return null;
+  }
+  const normalizedInput = normalizeText(inputValue);
+  const normalizedRules = Array.isArray(tipRules) ? tipRules : [];
+  if (!normalizedInput && normalizedRules.length === 0) {
+    return null;
+  }
+  const matchedRule = normalizedRules.find((rule) => {
+    const keywords = Array.isArray(rule?.keywords) ? rule.keywords : [];
+    const hasKeywordMatch = normalizedInput && hasAnyKeyword(normalizedInput, keywords);
+    const contextKey = String(rule?.whenContextKey || '').trim();
+    const hasContextMatch = contextKey ? contextFlags?.[contextKey] === true : false;
+    return hasKeywordMatch || hasContextMatch;
+  });
+  if (!matchedRule) {
+    return null;
+  }
+  return {
+    source: String(matchedRule.source || 'local_input_tip'),
+    modeKey: String(matchedRule.modeKey || '').trim(),
+    label: String(matchedRule.label || '').trim(),
+    reason: String(matchedRule.reason || '').trim(),
+    actionText: String(matchedRule.actionText || '').trim(),
+    statusOnly: matchedRule.statusOnly === true,
+  };
+}
+
+export default function useComposerModeSuggestion({
+  inputValue,
+  activeModeKey,
+  modeSuggestion,
+  modeSuggestionAction,
+  tipRules = [],
+  contextFlags = {},
+}) {
+  return useMemo(() => {
+    if (modeSuggestionAction && typeof modeSuggestionAction === 'object') {
+      return {
+        modeSuggestion: modeSuggestion || null,
+        modeSuggestionAction,
+        fromFallback: false,
+      };
+    }
+    const fallbackSuggestion = buildSuggestionFromInput({
+      inputValue,
+      activeModeKey,
+      tipRules,
+      contextFlags,
+    });
+    if (!fallbackSuggestion) {
+      return {
+        modeSuggestion: modeSuggestion || null,
+        modeSuggestionAction: null,
+        fromFallback: false,
+      };
+    }
+    return {
+      modeSuggestion: fallbackSuggestion,
+      modeSuggestionAction: {
+        source: 'mode_suggestion',
+        text: fallbackSuggestion.actionText || `启用${fallbackSuggestion.label || fallbackSuggestion.modeKey || ''}`,
+        action: {
+          action_type: 'switch_mode',
+          target_mode: fallbackSuggestion.modeKey,
+          label: fallbackSuggestion.actionText || '',
+        },
+      },
+      fromFallback: true,
+    };
+  }, [activeModeKey, contextFlags, inputValue, modeSuggestion, modeSuggestionAction, tipRules]);
+}