@lobehub/lobehub 2.0.0-next.370 → 2.0.0-next.372

package/packages/prompts/src/prompts/userMemory/formatSearchResults.test.ts

@@ -8,6 +8,7 @@ describe('formatMemorySearchResults', () => {
     const result = formatMemorySearchResults({
       query: 'test query',
       results: {
+        activities: [],
         contexts: [],
         experiences: [],
         preferences: [],
@@ -21,6 +22,7 @@ describe('formatMemorySearchResults', () => {
     const result = formatMemorySearchResults({
       query: 'project',
       results: {
+        activities: [],
         contexts: [
           {
             accessedAt: new Date('2024-01-01'),
@@ -48,10 +50,46 @@ describe('formatMemorySearchResults', () => {
     expect(result).toMatchSnapshot();
   });
 
+  it('should format activity memories with scheduling and feedback details', () => {
+    const result = formatMemorySearchResults({
+      query: 'meeting',
+      results: {
+        activities: [
+          {
+            createdAt: new Date('2024-01-01'),
+            endsAt: new Date('2024-01-01T11:00:00Z'),
+            feedback: 'Great alignment',
+            id: 'act-1',
+            metadata: null,
+            narrative: 'Covered Q1 roadmap and risks',
+            notes: 'Share slides after the call',
+            startsAt: new Date('2024-01-01T10:00:00Z'),
+            status: 'scheduled',
+            timezone: 'UTC',
+            type: 'meeting',
+            updatedAt: new Date('2024-01-01'),
+            userMemoryId: null,
+            associatedLocations: [],
+            associatedObjects: [],
+            associatedSubjects: [],
+            tags: ['meeting', 'Q1'],
+            accessedAt: new Date('2024-01-01'),
+          },
+        ],
+        contexts: [],
+        experiences: [],
+        preferences: [],
+      },
+    });
+
+    expect(result).toMatchSnapshot();
+  });
+
   it('should format experience memories with full content', () => {
     const result = formatMemorySearchResults({
       query: 'debugging',
       results: {
+        activities: [],
         contexts: [],
         experiences: [
           {
@@ -82,6 +120,7 @@ describe('formatMemorySearchResults', () => {
     const result = formatMemorySearchResults({
       query: 'code style',
       results: {
+        activities: [],
         contexts: [],
         experiences: [],
         preferences: [
@@ -109,6 +148,7 @@ describe('formatMemorySearchResults', () => {
     const result = formatMemorySearchResults({
       query: 'work',
       results: {
+        activities: [],
         contexts: [
           {
             accessedAt: new Date('2024-01-01'),
@@ -171,6 +211,7 @@ describe('formatMemorySearchResults', () => {
     const result = formatMemorySearchResults({
       query: 'test',
       results: {
+        activities: [],
         contexts: [
           {
             accessedAt: new Date('2024-01-01'),

package/packages/prompts/src/prompts/userMemory/formatSearchResults.ts

@@ -4,9 +4,16 @@ import type { SearchMemoryResult } from '@lobechat/types';
  * Search result item interfaces matching the SearchMemoryResult type
  */
 type ContextResult = SearchMemoryResult['contexts'][number];
+type ActivityResult = SearchMemoryResult['activities'][number];
 type ExperienceResult = SearchMemoryResult['experiences'][number];
 type PreferenceResult = SearchMemoryResult['preferences'][number];
 
+const formatDate = (value?: string | Date | null) => {
+  if (!value) return value;
+
+  return value instanceof Date ? value.toISOString() : value;
+};
+
 /**
  * Format a single context memory item for search results
  * Format: attributes for metadata, description as text content
@@ -64,6 +71,48 @@ const formatContextResult = (item: ContextResult): string => {
   return `  <context ${attrs.join(' ')}>${content}</context>`;
 };
 
+/**
+ * Format a single activity memory item for search results
+ * Includes scheduling attributes and feedback
+ */
+const formatActivityResult = (item: ActivityResult): string => {
+  const attrs: string[] = [`id="${item.id}"`];
+
+  if (item.type) {
+    attrs.push(`type="${item.type}"`);
+  }
+  if (item.status) {
+    attrs.push(`status="${item.status}"`);
+  }
+  const startsAt = formatDate(item.startsAt);
+  if (startsAt) {
+    attrs.push(`startsAt="${startsAt}"`);
+  }
+  const endsAt = formatDate(item.endsAt);
+  if (endsAt) {
+    attrs.push(`endsAt="${endsAt}"`);
+  }
+  if (item.timezone) {
+    attrs.push(`timezone="${item.timezone}"`);
+  }
+
+  const children: string[] = [];
+
+  if (item.feedback) {
+    children.push(`    <feedback>${item.feedback}</feedback>`);
+  }
+  if (item.narrative) {
+    children.push(`    <narrative>${item.narrative}</narrative>`);
+  }
+  if (item.notes) {
+    children.push(`    <notes>${item.notes}</notes>`);
+  }
+
+  const content = children.length > 0 ? `\n${children.join('\n')}\n  ` : '';
+
+  return `  <activity ${attrs.join(' ')}>${content}</activity>`;
+};
+
 /**
  * Format a single experience memory item for search results
  * Format: attributes for metadata, situation and keyLearning as child elements
@@ -129,8 +178,8 @@ export const formatMemorySearchResults = ({
   query,
   results,
 }: FormatSearchResultsOptions): string => {
-  const { contexts, experiences, preferences } = results;
-  const total = contexts.length + experiences.length + preferences.length;
+  const { activities, contexts, experiences, preferences } = results;
+  const total = activities.length + contexts.length + experiences.length + preferences.length;
 
   if (total === 0) {
     return `<memories query="${query}">
@@ -146,6 +195,11 @@ export const formatMemorySearchResults = ({
     sections.push(`<contexts count="${contexts.length}">\n${contextsXml}\n</contexts>`);
   }
 
+  if (activities.length > 0) {
+    const activitiesXml = activities.map(formatActivityResult).join('\n');
+    sections.push(`<activities count="${activities.length}">\n${activitiesXml}\n</activities>`);
+  }
+
   // Add experiences section
   if (experiences.length > 0) {
     const experiencesXml = experiences.map(formatExperienceResult).join('\n');

package/packages/types/src/userMemory/activity.ts

@@ -0,0 +1,19 @@
+import type { BaseListItem, BaseListParams, BaseListResult } from './shared';
+
+export type ActivityListSort = 'capturedAt' | 'startsAt';
+
+export interface ActivityListParams extends BaseListParams {
+  sort?: ActivityListSort;
+  status?: string[];
+}
+
+export interface ActivityListItem extends BaseListItem {
+  endsAt: Date | null;
+  narrative: string | null;
+  notes: string | null;
+  startsAt: Date | null;
+  status: string | null;
+  timezone: string | null;
+}
+
+export type ActivityListResult = BaseListResult<ActivityListItem>;

package/packages/types/src/userMemory/index.ts

@@ -1,4 +1,5 @@
 export * from './base';
+export * from './activity';
 export * from './experience';
 export * from './identity';
 export * from './layers';

package/packages/types/src/userMemory/tools.ts

@@ -1,6 +1,11 @@
 import { z } from 'zod';
 
-import { UserMemoryContext, UserMemoryExperience, UserMemoryPreference } from './layers';
+import {
+  UserMemoryActivity,
+  UserMemoryContext,
+  UserMemoryExperience,
+  UserMemoryPreference,
+} from './layers';
 
 export const searchMemorySchema = z.object({
   // TODO: we need to dynamically fetch the available categories/types from the backend
@@ -8,6 +13,7 @@ export const searchMemorySchema = z.object({
   // memoryType: z.string().optional(),
   query: z.string(),
   topK: z.object({
+    activities: z.coerce.number().int().min(0),
     contexts: z.coerce.number().int().min(0),
     experiences: z.coerce.number().int().min(0),
     preferences: z.coerce.number().int().min(0),
@@ -17,6 +23,9 @@ export const searchMemorySchema = z.object({
 export type SearchMemoryParams = z.infer<typeof searchMemorySchema>;
 
 export interface SearchMemoryResult {
+  activities: Array<
+    Omit<UserMemoryActivity, 'userId' | 'narrativeVector' | 'feedbackVector'>
+  >;
   contexts: Array<Omit<UserMemoryContext, 'userId' | 'titleVector' | 'descriptionVector'>>;
   experiences: Array<
     Omit<UserMemoryExperience, 'userId' | 'actionVector' | 'situationVector' | 'keyLearningVector'>

package/src/app/(backend)/api/dev/memory-user-memory/benchmark-locomo/route.ts

@@ -82,6 +82,7 @@ export const POST = async (req: Request) => {
     const searchResult = await model.searchWithEmbedding({
       embedding,
       limits: {
+        activities: topK,
         contexts: topK,
         experiences: topK,
         preferences: topK,
@@ -102,6 +103,9 @@ export const POST = async (req: Request) => {
       ...searchResult.preferences
         .map((preference) => preference.userMemoryId)
         .filter((id): id is string => !!id),
+      ...searchResult.activities
+        .map((activity) => activity.userMemoryId)
+        .filter((id): id is string => !!id),
       ...identities
         .map((identity) => identity.userMemoryId)
         .filter((id): id is string => !!id),
@@ -179,10 +183,25 @@ export const POST = async (req: Request) => {
       })
       .filter(Boolean);
 
+    const activityItems = searchResult.activities
+      .map((activity) => {
+        const memory = activity.userMemoryId ? memoryMap.get(activity.userMemoryId) : undefined;
+        if (!memory) return undefined;
+
+        return {
+          activity,
+          id: activity.userMemoryId,
+          layer: LayersEnum.Activity,
+          memory,
+        };
+      })
+      .filter(Boolean);
+
     const items = [
       ...contextItems.slice(0, topK),
       ...experienceItems.slice(0, topK),
       ...preferenceItems.slice(0, topK),
+      ...activityItems.slice(0, topK),
       ...identityItems,
     ];
     console.log('[locomo-dev-search] compiled items');

package/src/app/[variants]/(main)/memory/_layout/Sidebar/Header/Nav.tsx

@@ -2,6 +2,7 @@
 
 import { Flexbox } from '@lobehub/ui';
 import {
+  CalendarClockIcon,
   BrainCircuitIcon,
   BubblesIcon,
   HeartPulseIcon,
@@ -26,6 +27,7 @@ interface Item {
 }
 
 enum MemoryTabKey {
+  Activities = 'activities',
   Contexts = 'contexts',
   Experiences = 'experiences',
   Home = 'home',
@@ -85,6 +87,12 @@ const Nav = memo(() => {
         title: t('tab.experiences'),
         url: '/memory/experiences',
       },
+      {
+        icon: CalendarClockIcon,
+        key: MemoryTabKey.Activities,
+        title: t('tab.activities'),
+        url: '/memory/activities',
+      },
     ],
     [t],
   );

package/src/app/[variants]/(main)/memory/activities/features/ActivityDropdown.tsx

@@ -0,0 +1,68 @@
+import { ActionIcon, type ActionIconProps, DropdownMenu } from '@lobehub/ui';
+import { App } from 'antd';
+import { MoreHorizontal, Pencil, Trash2 } from 'lucide-react';
+import { type KeyboardEvent, type MouseEvent, memo } from 'react';
+import { useTranslation } from 'react-i18next';
+
+import { useUserMemoryStore } from '@/store/userMemory';
+
+interface ActivityDropdownProps {
+  id: string;
+  size?: ActionIconProps['size'];
+}
+
+const ActivityDropdown = memo<ActivityDropdownProps>(({ id, size = 'small' }) => {
+  const { t } = useTranslation(['memory', 'common']);
+  const { modal } = App.useApp();
+
+  const activities = useUserMemoryStore((s) => s.activities);
+  const deleteActivity = useUserMemoryStore((s) => s.deleteActivity);
+  const setEditingMemory = useUserMemoryStore((s) => s.setEditingMemory);
+
+  const handleMenuClick = (info: { domEvent: MouseEvent | KeyboardEvent; key: string }) => {
+    info.domEvent.stopPropagation();
+
+    if (info.key === 'edit') {
+      const activity = activities.find((item) => item.id === id);
+      if (activity) {
+        setEditingMemory(id, activity.narrative || activity.notes || '', 'activity');
+      }
+    } else if (info.key === 'delete') {
+      modal.confirm({
+        cancelText: t('cancel', { ns: 'common' }),
+        content: t('activity.deleteConfirm'),
+        okButtonProps: { danger: true },
+        okText: t('confirm', { ns: 'common' }),
+        onOk: async () => {
+          await deleteActivity(id);
+        },
+        title: t('activity.deleteTitle'),
+        type: 'warning',
+      });
+    }
+  };
+
+  const menuItems = [
+    {
+      icon: <Pencil size={14} />,
+      key: 'edit',
+      label: t('activity.actions.edit'),
+      onClick: handleMenuClick,
+    },
+    {
+      danger: true,
+      icon: <Trash2 size={14} />,
+      key: 'delete',
+      label: t('activity.actions.delete'),
+      onClick: handleMenuClick,
+    },
+  ];
+
+  return (
+    <DropdownMenu items={menuItems}>
+      <ActionIcon icon={MoreHorizontal} size={size} />
+    </DropdownMenu>
+  );
+});
+
+export default ActivityDropdown;

package/src/app/[variants]/(main)/memory/activities/features/ActivityRightPanel.tsx

@@ -0,0 +1,113 @@
+'use client';
+
+import { Flexbox, Tag, Text } from '@lobehub/ui';
+import dayjs from 'dayjs';
+import { memo, useMemo } from 'react';
+import { useTranslation } from 'react-i18next';
+
+import CateTag from '@/app/[variants]/(main)/memory/features/CateTag';
+import DetailLoading from '@/app/[variants]/(main)/memory/features/DetailLoading';
+import DetailPanel from '@/app/[variants]/(main)/memory/features/DetailPanel';
+import HashTags from '@/app/[variants]/(main)/memory/features/HashTags';
+import HighlightedContent from '@/app/[variants]/(main)/memory/features/HighlightedContent';
+import SourceLink from '@/app/[variants]/(main)/memory/features/SourceLink';
+import Time from '@/app/[variants]/(main)/memory/features/Time';
+import { DESKTOP_HEADER_ICON_SIZE } from '@/const/layoutTokens';
+import { useQueryState } from '@/hooks/useQueryParam';
+import { useUserMemoryStore } from '@/store/userMemory';
+import { LayersEnum } from '@/types/userMemory';
+
+import ActivityDropdown from './ActivityDropdown';
+
+const formatTime = (value?: Date | string | null) => {
+  if (!value) return null;
+  const time = dayjs(value);
+  if (!time.isValid()) return null;
+  return time.format('YYYY-MM-DD HH:mm');
+};
+
+const ActivityRightPanel = memo(() => {
+  const { t } = useTranslation('memory');
+  const [activityId] = useQueryState('activityId', { clearOnDefault: true });
+  const useFetchMemoryDetail = useUserMemoryStore((s) => s.useFetchMemoryDetail);
+
+  const { data: activity, isLoading } = useFetchMemoryDetail(activityId, LayersEnum.Activity);
+
+  const schedule = useMemo(() => {
+    if (!activity) return null;
+    const start = formatTime(activity.startsAt);
+    const end = formatTime(activity.endsAt);
+    if (!start && !end) return null;
+    if (start && end) return `${start} → ${end}`;
+    return start || end;
+  }, [activity]);
+
+  if (!activityId) return null;
+
+  let content;
+  if (isLoading) content = <DetailLoading />;
+  if (activity) {
+    const capturedAt =
+      activity.startsAt ||
+      activity.capturedAt ||
+      activity.updatedAt ||
+      activity.createdAt ||
+      undefined;
+
+    content = (
+      <>
+        <CateTag cate={activity.type} />
+        <Text
+          as={'h1'}
+          fontSize={20}
+          style={{
+            lineHeight: 1.4,
+            marginBottom: 0,
+          }}
+          weight={'bold'}
+        >
+          {activity.title || t('activity.defaultType')}
+        </Text>
+        <Flexbox align="center" gap={16} horizontal justify="space-between">
+          {activity.status && <Tag>{activity.status}</Tag>}
+          <SourceLink source={activity.source} />
+        </Flexbox>
+        <Flexbox align="center" gap={16} horizontal justify="space-between">
+          <Time capturedAt={capturedAt} />
+          {activity.timezone && (
+            <Text fontSize={12} type="secondary">
+              {activity.timezone}
+            </Text>
+          )}
+        </Flexbox>
+
+        {schedule && <HighlightedContent>{schedule}</HighlightedContent>}
+        {activity.narrative && (
+          <HighlightedContent title={t('activity.narrative')}>{activity.narrative}</HighlightedContent>
+        )}
+        {activity.notes && (
+          <HighlightedContent title={t('activity.notes')}>{activity.notes}</HighlightedContent>
+        )}
+        {activity.feedback && (
+          <HighlightedContent title={t('activity.feedback')}>{activity.feedback}</HighlightedContent>
+        )}
+
+        <HashTags hashTags={activity.tags} />
+      </>
+    );
+  }
+
+  return (
+    <DetailPanel
+      header={{
+        right: activityId ? (
+          <ActivityDropdown id={activityId} size={DESKTOP_HEADER_ICON_SIZE} />
+        ) : undefined,
+      }}
+    >
+      {content}
+    </DetailPanel>
+  );
+});
+
+export default ActivityRightPanel;

package/src/app/[variants]/(main)/memory/activities/features/List/GridView/ActivityCard.tsx

@@ -0,0 +1,36 @@
+import type { ActivityListItem } from '@lobechat/types';
+import { Tag } from '@lobehub/ui';
+import { memo } from 'react';
+import { useTranslation } from 'react-i18next';
+
+import GridCard from '@/app/[variants]/(main)/memory/features/GridView/GridCard';
+
+import ActivityDropdown from '../../ActivityDropdown';
+
+interface ActivityCardProps {
+  activity: ActivityListItem;
+  onClick: (activity: ActivityListItem) => void;
+}
+
+const ActivityCard = memo<ActivityCardProps>(({ activity, onClick }) => {
+  const { t } = useTranslation('memory');
+  const capturedAt =
+    activity.startsAt || activity.capturedAt || activity.updatedAt || activity.createdAt;
+
+  return (
+    <GridCard
+      actions={<ActivityDropdown id={activity.id} />}
+      badges={activity.status ? <Tag>{activity.status}</Tag> : undefined}
+      capturedAt={capturedAt}
+      cate={activity.type}
+      hashTags={activity.tags}
+      onClick={() => onClick(activity)}
+      title={activity.title || t('activity.defaultType')}
+      titleAddon={activity.timezone}
+    >
+      {activity.narrative || activity.notes || t('activity.defaultType')}
+    </GridCard>
+  );
+});
+
+export default ActivityCard;

package/src/app/[variants]/(main)/memory/activities/features/List/GridView/index.tsx

@@ -0,0 +1,32 @@
+import type { ActivityListItem } from '@lobechat/types';
+import { memo } from 'react';
+
+import { useUserMemoryStore } from '@/store/userMemory';
+
+import { GridView } from '../../../../features/GridView';
+import ActivityCard from './ActivityCard';
+
+interface GridViewProps {
+  activities: ActivityListItem[];
+  isLoading?: boolean;
+  onClick: (activity: ActivityListItem) => void;
+}
+
+const ActivitiesGridView = memo<GridViewProps>(({ activities, isLoading, onClick }) => {
+  const loadMoreActivities = useUserMemoryStore((s) => s.loadMoreActivities);
+  const activitiesHasMore = useUserMemoryStore((s) => s.activitiesHasMore);
+
+  return (
+    <GridView
+      hasMore={activitiesHasMore}
+      isLoading={isLoading}
+      items={activities}
+      onLoadMore={loadMoreActivities}
+      renderItem={(activity: ActivityListItem) => (
+        <ActivityCard activity={activity} onClick={() => onClick(activity)} />
+      )}
+    />
+  );
+});
+
+export default ActivitiesGridView;

package/src/app/[variants]/(main)/memory/activities/features/List/TimelineView/ActivityCard.tsx

@@ -0,0 +1,34 @@
+import type { ActivityListItem } from '@lobechat/types';
+import { memo } from 'react';
+import { useTranslation } from 'react-i18next';
+
+import TimeLineCard from '@/app/[variants]/(main)/memory/features/TimeLineView/TimeLineCard';
+
+import ActivityDropdown from '../../ActivityDropdown';
+
+interface ActivityCardProps {
+  activity: ActivityListItem;
+  onClick: (activity: ActivityListItem) => void;
+}
+
+const ActivityCard = memo<ActivityCardProps>(({ activity, onClick }) => {
+  const { t } = useTranslation('memory');
+  const capturedAt =
+    activity.startsAt || activity.capturedAt || activity.updatedAt || activity.createdAt;
+
+  return (
+    <TimeLineCard
+      actions={<ActivityDropdown id={activity.id} />}
+      capturedAt={capturedAt}
+      cate={activity.type}
+      hashTags={activity.tags}
+      onClick={() => onClick(activity)}
+      title={activity.title || t('activity.defaultType')}
+      titleAddon={activity.status}
+    >
+      {activity.narrative || activity.notes || activity.status || t('activity.defaultType')}
+    </TimeLineCard>
+  );
+});
+
+export default ActivityCard;

package/src/app/[variants]/(main)/memory/activities/features/List/TimelineView/index.tsx

@@ -0,0 +1,41 @@
+'use client';
+
+import type { ActivityListItem } from '@lobechat/types';
+import { memo } from 'react';
+
+import { useUserMemoryStore } from '@/store/userMemory';
+
+import { TimelineView as GenericTimelineView } from '../../../../features/TimeLineView';
+import { PeriodHeader, TimelineItemWrapper } from '../../../../features/TimeLineView/PeriodGroup';
+import ActivityCard from './ActivityCard';
+
+interface ActivityTimelineViewProps {
+  activities: ActivityListItem[];
+  isLoading?: boolean;
+  onCardClick: (activity: ActivityListItem) => void;
+}
+
+const ActivityTimelineView = memo<ActivityTimelineViewProps>(
+  ({ activities, isLoading, onCardClick }) => {
+    const loadMoreActivities = useUserMemoryStore((s) => s.loadMoreActivities);
+    const activitiesHasMore = useUserMemoryStore((s) => s.activitiesHasMore);
+
+    return (
+      <GenericTimelineView
+        data={activities}
+        groupBy="day"
+        hasMore={activitiesHasMore}
+        isLoading={isLoading}
+        onLoadMore={loadMoreActivities}
+        renderHeader={(periodKey: string) => <PeriodHeader groupBy="day" periodKey={periodKey} />}
+        renderItem={(activity: ActivityListItem) => (
+          <TimelineItemWrapper>
+            <ActivityCard activity={activity} onClick={onCardClick} />
+          </TimelineItemWrapper>
+        )}
+      />
+    );
+  },
+);
+
+export default ActivityTimelineView;

package/src/app/[variants]/(main)/memory/activities/features/List/index.tsx

@@ -0,0 +1,43 @@
+import { memo } from 'react';
+import { useTranslation } from 'react-i18next';
+
+import MemoryEmpty from '@/app/[variants]/(main)/memory/features/MemoryEmpty';
+import { useQueryState } from '@/hooks/useQueryParam';
+import { useGlobalStore } from '@/store/global';
+import { useUserMemoryStore } from '@/store/userMemory';
+
+import { type ViewMode } from '../../../features/ViewModeSwitcher';
+import GridView from './GridView';
+import TimelineView from './TimelineView';
+
+interface ActivitiesListProps {
+  isLoading?: boolean;
+  searchValue?: string;
+  viewMode: ViewMode;
+}
+
+const ActivitiesList = memo<ActivitiesListProps>(({ isLoading, searchValue, viewMode }) => {
+  const { t } = useTranslation(['memory', 'common']);
+  const [, setActivityId] = useQueryState('activityId', { clearOnDefault: true });
+  const toggleRightPanel = useGlobalStore((s) => s.toggleRightPanel);
+  const activities = useUserMemoryStore((s) => s.activities);
+
+  const handleCardClick = (activity: any) => {
+    setActivityId(activity.id);
+    toggleRightPanel(true);
+  };
+
+  const isEmpty = activities.length === 0;
+
+  if (isEmpty) {
+    return <MemoryEmpty search={Boolean(searchValue)} title={t('activity.empty')} />;
+  }
+
+  return viewMode === 'timeline' ? (
+    <TimelineView activities={activities} isLoading={isLoading} onCardClick={handleCardClick} />
+  ) : (
+    <GridView activities={activities} isLoading={isLoading} onClick={handleCardClick} />
+  );
+});
+
+export default ActivitiesList;