@lobehub/lobehub 2.0.0-next.293 → 2.0.0-next.295

package/packages/types/src/discover/assistants.ts

@@ -18,7 +18,7 @@ export enum AssistantCategory {
   Marketing = 'marketing',
   Office = 'office',
   Programming = 'programming',
-  Translation = 'translation'
+  Translation = 'translation',
 }
 
 export enum AssistantSorts {
@@ -29,7 +29,7 @@ export enum AssistantSorts {
   PluginCount = 'pluginCount',
   Recommended = 'recommended',
   Title = 'title',
-  TokenUsage = 'tokenUsage'
+  TokenUsage = 'tokenUsage',
 }
 
 export enum AssistantNavKey {

package/scripts/migrate-spa-navigation.ts

@@ -0,0 +1,129 @@
+#!/usr/bin/env bun
+/**
+ * Script to migrate SPA internal components from @/libs/next/navigation
+ * to React Router version hooks.
+ *
+ * For files in (main) directory:
+ * - usePathname -> @/app/[variants]/(main)/hooks/usePathname
+ * - useSearchParams -> @/app/[variants]/(main)/hooks/useSearchParams
+ * - useRouter -> @/app/[variants]/(main)/hooks/useRouter
+ *
+ * @see RFC 147: LOBE-2850 - Phase 3
+ */
+
+import { readFile, writeFile } from 'node:fs/promises';
+import { dirname, join, relative } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+// Files that should be migrated to React Router version
+const SPA_FILES = [
+  // (main) directory files using @/libs/next/navigation
+  'src/app/[variants]/(main)/community/_layout/Sidebar/Header/Nav.tsx',
+  'src/app/[variants]/(main)/group/_layout/Sidebar/Header/Nav.tsx',
+  'src/app/[variants]/(main)/group/_layout/Sidebar/Topic/hooks/useTopicNavigation.ts',
+  'src/app/[variants]/(main)/group/_layout/Sidebar/Topic/hooks/useThreadNavigation.ts',
+  'src/app/[variants]/(main)/chat/_layout/Sidebar/Header/AddTopicButon.tsx',
+  'src/app/[variants]/(main)/chat/_layout/Sidebar/Header/Nav.tsx',
+  'src/app/[variants]/(main)/chat/_layout/Sidebar/Topic/hooks/useTopicNavigation.ts',
+  'src/app/[variants]/(main)/chat/_layout/Sidebar/Topic/hooks/useThreadNavigation.ts',
+  'src/app/[variants]/(main)/memory/_layout/Sidebar/Header/Nav.tsx',
+];
+
+interface MigrationResult {
+  changes: string[];
+  filePath: string;
+}
+
+async function migrateFile(relativePath: string): Promise<MigrationResult | null> {
+  const fullPath = join(__dirname, '..', relativePath);
+  const content = await readFile(fullPath, 'utf8');
+  let newContent = content;
+  const changes: string[] = [];
+
+  // Check what hooks are being imported from @/libs/next/navigation
+  const importMatch = content.match(
+    /import\s*\{([^}]+)\}\s*from\s*['"]@\/libs\/next\/navigation['"]/
+  );
+
+  if (!importMatch) {
+    console.log(`⏭️  ${relativePath} - No @/libs/next/navigation import found`);
+    return null;
+  }
+
+  const importedHooks = importMatch[1]
+    .split(',')
+    .map((s) => s.trim())
+    .filter(Boolean);
+
+  console.log(`📝 ${relativePath}`);
+  console.log(`   Imported hooks: ${importedHooks.join(', ')}`);
+
+  // Build new imports
+  const newImports: string[] = [];
+
+  for (const hook of importedHooks) {
+    if (hook === 'usePathname') {
+      newImports.push(`import { usePathname } from '@/app/[variants]/(main)/hooks/usePathname';`);
+      changes.push('usePathname -> React Router version');
+    } else if (hook === 'useSearchParams') {
+      newImports.push(
+        `import { useSearchParams } from '@/app/[variants]/(main)/hooks/useSearchParams';`
+      );
+      changes.push('useSearchParams -> React Router version');
+    } else if (hook === 'useRouter') {
+      newImports.push(`import { useRouter } from '@/app/[variants]/(main)/hooks/useRouter';`);
+      changes.push('useRouter -> React Router version');
+    } else {
+      // Keep other imports (like notFound, redirect) from next/navigation
+      console.log(`   ⚠️  Unknown hook "${hook}" - keeping original import`);
+    }
+  }
+
+  if (newImports.length === 0) {
+    console.log(`   ⏭️  No hooks to migrate`);
+    return null;
+  }
+
+  // Replace the old import with new imports
+  newContent = newContent.replace(
+    /import\s*\{[^}]+\}\s*from\s*['"]@\/libs\/next\/navigation['"];?\n?/,
+    newImports.join('\n') + '\n'
+  );
+
+  if (newContent !== content) {
+    await writeFile(fullPath, newContent, 'utf8');
+    for (const change of changes) {
+      console.log(`   ✅ ${change}`);
+    }
+    return { changes, filePath: relativePath };
+  }
+
+  return null;
+}
+
+async function main() {
+  console.log('🚀 Starting SPA navigation migration...\n');
+
+  const results: MigrationResult[] = [];
+
+  for (const file of SPA_FILES) {
+    try {
+      const result = await migrateFile(file);
+      if (result) {
+        results.push(result);
+      }
+    } catch (error) {
+      console.error(`❌ Error processing ${file}:`, error);
+    }
+  }
+
+  console.log('\n' + '='.repeat(60));
+  console.log(`📊 Migration Summary:`);
+  console.log(`   - Files processed: ${SPA_FILES.length}`);
+  console.log(`   - Files modified: ${results.length}`);
+  console.log('\n✨ SPA navigation migration complete!');
+}
+
+await main();

package/src/app/(backend)/api/workflows/memory-user-memory/pipelines/chat-topic/process-topics/route.ts

@@ -4,143 +4,145 @@ import {
   tracer as upstashWorkflowTracer,
 } from '@lobechat/observability-otel/modules/upstash-workflow';
 import { LayersEnum, MemorySourceType } from '@lobechat/types';
-import { serve } from '@upstash/workflow/nextjs';
+import { Client } from '@upstash/qstash';
 import { WorkflowAbort } from '@upstash/workflow';
+import { serve } from '@upstash/workflow/nextjs';
 
+import { parseMemoryExtractionConfig } from '@/server/globalConfig/parseMemoryExtractionConfig';
 import {
   MemoryExtractionExecutor,
   type MemoryExtractionPayloadInput,
   normalizeMemoryExtractionPayload,
 } from '@/server/services/memory/userMemory/extract';
-import { Client } from '@upstash/qstash'
-import { parseMemoryExtractionConfig } from '@/server/globalConfig/parseMemoryExtractionConfig';
 
 const { upstashWorkflowExtraHeaders } = parseMemoryExtractionConfig();
 
 const CEP_LAYERS: LayersEnum[] = [LayersEnum.Context, LayersEnum.Experience, LayersEnum.Preference];
 const IDENTITY_LAYERS: LayersEnum[] = [LayersEnum.Identity];
 
-export const { POST } = serve<MemoryExtractionPayloadInput>((context) =>
-  upstashWorkflowTracer.startActiveSpan(
-    'workflow:memory-user-memory:process-topics',
-    async (span) => {
-      const payload = normalizeMemoryExtractionPayload(context.requestPayload || {});
-
-      span.setAttributes({
-        ...buildUpstashWorkflowAttributes(context),
-        'workflow.memory_user_memory.force_all': payload.forceAll,
-        'workflow.memory_user_memory.force_topics': payload.forceTopics,
-        'workflow.memory_user_memory.layers': payload.layers.join(','),
-        'workflow.memory_user_memory.source': payload.sources.join(','),
-        'workflow.memory_user_memory.topic_count': payload.topicIds.length,
-        'workflow.memory_user_memory.user_count': payload.userIds.length,
-        'workflow.name': 'memory-user-memory:process-topics',
-      });
-
-      try {
-        console.log('[chat-topic][batch] Starting batch topic processing workflow', {
-          topicIds: payload.topicIds,
-          userIds: payload.userIds,
+export const { POST } = serve<MemoryExtractionPayloadInput>(
+  (context) =>
+    upstashWorkflowTracer.startActiveSpan(
+      'workflow:memory-user-memory:process-topics',
+      async (span) => {
+        const payload = normalizeMemoryExtractionPayload(context.requestPayload || {});
+
+        span.setAttributes({
+          ...buildUpstashWorkflowAttributes(context),
+          'workflow.memory_user_memory.force_all': payload.forceAll,
+          'workflow.memory_user_memory.force_topics': payload.forceTopics,
+          'workflow.memory_user_memory.layers': payload.layers.join(','),
+          'workflow.memory_user_memory.source': payload.sources.join(','),
+          'workflow.memory_user_memory.topic_count': payload.topicIds.length,
+          'workflow.memory_user_memory.user_count': payload.userIds.length,
+          'workflow.name': 'memory-user-memory:process-topics',
         });
 
-        if (!payload.userIds.length) {
-          span.setStatus({ code: SpanStatusCode.OK });
-
-          return {
-            message: 'No user id provided for topic batch.',
-            processedTopics: 0,
-            processedUsers: 0,
-          };
-        }
-        if (!payload.topicIds.length) {
-          span.setStatus({ code: SpanStatusCode.OK });
-
-          return {
-            message: 'No topic ids provided for extraction.',
-            processedTopics: 0,
-            processedUsers: 0,
-          };
-        }
-        if (!payload.sources.includes(MemorySourceType.ChatTopic)) {
-          span.setStatus({ code: SpanStatusCode.OK });
-
-          return {
-            message: 'Source not supported in topic batch.',
-            processedTopics: 0,
-            processedUsers: 0,
-          };
-        }
-
-        const userId = payload.userIds[0];
-        const executor = await MemoryExtractionExecutor.create();
+        try {
+          console.log('[chat-topic][batch] Starting batch topic processing workflow', {
+            topicIds: payload.topicIds,
+            userIds: payload.userIds,
+          });
+
+          if (!payload.userIds.length) {
+            span.setStatus({ code: SpanStatusCode.OK });
+
+            return {
+              message: 'No user id provided for topic batch.',
+              processedTopics: 0,
+              processedUsers: 0,
+            };
+          }
+          if (!payload.topicIds.length) {
+            span.setStatus({ code: SpanStatusCode.OK });
+
+            return {
+              message: 'No topic ids provided for extraction.',
+              processedTopics: 0,
+              processedUsers: 0,
+            };
+          }
+          if (!payload.sources.includes(MemorySourceType.ChatTopic)) {
+            span.setStatus({ code: SpanStatusCode.OK });
+
+            return {
+              message: 'Source not supported in topic batch.',
+              processedTopics: 0,
+              processedUsers: 0,
+            };
+          }
+
+          const userId = payload.userIds[0];
+          const executor = await MemoryExtractionExecutor.create();
+
+          // CEP: run in parallel across the batch
+          await Promise.all(
+            payload.topicIds.map((topicId, index) =>
+              context.run(
+                `memory:user-memory:extract:users:${userId}:topics:${topicId}:cep:${index}`,
+                () =>
+                  executor.extractTopic({
+                    forceAll: payload.forceAll,
+                    forceTopics: payload.forceTopics,
+                    from: payload.from,
+                    layers: CEP_LAYERS,
+                    source: MemorySourceType.ChatTopic,
+                    to: payload.to,
+                    topicId,
+                    userId,
+                  }),
+              ),
+            ),
+          );
 
-        // CEP: run in parallel across the batch
-        await Promise.all(
-          payload.topicIds.map((topicId, index) =>
-            context.run(
-              `memory:user-memory:extract:users:${userId}:topics:${topicId}:cep:${index}`,
+          // Identity: run sequentially for the batch
+          for (const [index, topicId] of payload.topicIds.entries()) {
+            await context.run(
+              `memory:user-memory:extract:users:${userId}:topics:${topicId}:identity:${index}`,
               () =>
                 executor.extractTopic({
                   forceAll: payload.forceAll,
                   forceTopics: payload.forceTopics,
                   from: payload.from,
-                  layers: CEP_LAYERS,
+                  layers: IDENTITY_LAYERS,
                   source: MemorySourceType.ChatTopic,
                   to: payload.to,
                   topicId,
                   userId,
                 }),
-            ),
-          ),
-        );
-
-        // Identity: run sequentially for the batch
-        for (const [index, topicId] of payload.topicIds.entries()) {
-          await context.run(
-            `memory:user-memory:extract:users:${userId}:topics:${topicId}:identity:${index}`,
-            () =>
-              executor.extractTopic({
-                forceAll: payload.forceAll,
-                forceTopics: payload.forceTopics,
-                from: payload.from,
-                layers: IDENTITY_LAYERS,
-                source: MemorySourceType.ChatTopic,
-                to: payload.to,
-                topicId,
-                userId,
-              }),
-          );
-        }
+            );
+          }
 
-        console.log('[chat-topic][batch] Batch topic processing workflow completed', {
-          processedTopics: payload.topicIds.length,
-        });
+          console.log('[chat-topic][batch] Batch topic processing workflow completed', {
+            processedTopics: payload.topicIds.length,
+          });
 
-        span.setStatus({ code: SpanStatusCode.OK });
+          span.setStatus({ code: SpanStatusCode.OK });
+
+          return {
+            processedTopics: payload.topicIds.length,
+            processedUsers: payload.userIds.length,
+          };
+        } catch (error) {
+          // NOTICE: Let WorkflowAbort bubble up (used internally by Upstash); record others
+          if (error instanceof WorkflowAbort) {
+            console.warn('workflow aborted:', error.message);
+            throw error;
+          }
+
+          span.recordException(error as Error);
+          span.setStatus({
+            code: SpanStatusCode.ERROR,
+            message: error instanceof Error ? error.message : 'process-topics workflow failed',
+          });
 
-        return {
-          processedTopics: payload.topicIds.length,
-          processedUsers: payload.userIds.length,
-        };
-      } catch (error) {
-        // NOTICE: Let WorkflowAbort bubble up (used internally by Upstash); record others
-        if (error instanceof WorkflowAbort) {
-          console.warn('workflow aborted:', error.message);
           throw error;
+        } finally {
+          span.end();
         }
-
-        span.recordException(error as Error);
-        span.setStatus({
-          code: SpanStatusCode.ERROR,
-          message: error instanceof Error ? error.message : 'process-topics workflow failed',
-        });
-
-        throw error;
-      } finally {
-        span.end();
-      }
-    },
-  ), {
+      },
+    ),
+  {
     // NOTICE(@nekomeowww): Here as scenarios like Vercel Deployment Protection,
     // intermediate context.run(...) won't offer customizable headers like context.trigger(...) / client.trigger(...)
     // for passing additional headers, we have to provide a custom QStash client with the required headers here.
@@ -151,6 +153,7 @@ export const { POST } = serve<MemoryExtractionPayloadInput>((context) =>
       headers: {
         ...upstashWorkflowExtraHeaders,
       },
-      token: process.env.QSTASH_TOKEN!
-    })
-});
+      token: process.env.QSTASH_TOKEN!,
+    }),
+  },
+);