create-pardx-scaffold 0.1.0

package/template/apps/web/lib/actions/chat.ts

@@ -0,0 +1,129 @@
+'use server';
+import request from '@/lib/requests';
+
+interface ChatSession {
+  agent_session_id: string;
+  session_id: string;
+  session_name: string;
+  session_state: Record<string, unknown>;
+  chat_history: unknown[];
+  created_at: string;
+  updated_at: string;
+}
+
+// 聊天详情类型定义
+export interface ChatSessionSummary {
+  summary: string;
+  updated_at: string;
+}
+
+export interface ChatModelDetail {
+  provider: string;
+  name: string;
+  id: string;
+}
+
+export interface AgentData {
+  name: string;
+  agent_id: string;
+  model: ChatModelDetail;
+}
+
+export interface ChatMetrics {
+  input_tokens: number;
+  output_tokens: number;
+  total_tokens: number;
+  audio_input_tokens: number;
+  audio_output_tokens: number;
+  audio_total_tokens: number;
+  cache_read_tokens: number;
+  cache_write_tokens: number;
+  reasoning_tokens: number;
+}
+
+export interface ChatMessage {
+  id: string;
+  content: string;
+  reasoning_content: string;
+  from_history: boolean;
+  stop_after_tool_call: boolean;
+  role: 'system' | 'user' | 'assistant';
+  created_at: number;
+  metrics?: {
+    input_tokens: number;
+    output_tokens: number;
+    total_tokens: number;
+  };
+  provider_data?: Record<string, unknown>;
+}
+
+// {
+//     "id": "df9e3a2b-ea4f-427a-955a-706c8a3d0b0b",
+//     "content": "12312",
+//     "from_history": false,
+//     "stop_after_tool_call": false,
+//     "role": "user",
+//     "created_at": 1768528561
+//   },
+
+export interface ChatDetail {
+  user_id: string;
+  agent_session_id: string;
+  session_id: string;
+  session_name: string;
+  session_summary: ChatSessionSummary;
+  session_state: Record<string, unknown>;
+  agent_id: string;
+  total_tokens: number;
+  agent_data: AgentData;
+  metrics: ChatMetrics;
+  chat_history: ChatMessage[];
+  created_at: string;
+  updated_at: string;
+}
+
+interface ChatSessionList {
+  data: ChatSession[];
+  meta: {
+    page: number;
+    limit: number;
+    total_pages: number;
+    total_count: number;
+    search_time_ms: number;
+  };
+}
+
+// 创建新对话
+export async function createSession(
+  type: 'agent' | 'workflow',
+  session_name: string,
+) {
+  return request.post<ChatSession>(`/sessions?type=${type}`, {
+    params: { session_name },
+  });
+}
+
+// 获取对话记录详情
+export async function getSession(session_id: string) {
+  return request.get<ChatDetail>(`/sessions/${session_id}`, {
+    cacheTime: 0,
+  });
+}
+
+// 删除历史对话
+export async function deleteSession(session_id: string) {
+  return request.delete(`/sessions/${session_id}`);
+}
+
+// 重命名历史对话记录
+export async function renameSession(
+  session_id: string,
+  session_name: string,
+  type = 'agent',
+) {
+  return request.post(`/sessions/${session_id}/rename?type=${type}`, {
+    params: {
+      session_name,
+    },
+  });
+}

package/template/apps/web/lib/actions/common.ts

@@ -0,0 +1,13 @@
+'use server';
+
+import request from '@/lib/requests';
+import type {
+  GetUploadUrlRequest,
+  GetUploadUrlResponse,
+} from '@repo/types/common';
+
+export async function getSignedUploadUrl(params: GetUploadUrlRequest) {
+  return request.post<GetUploadUrlResponse>('/v1/oss/upload-url', {
+    params,
+  });
+}

package/template/apps/web/lib/actions/task.ts

@@ -0,0 +1,20 @@
+'use server';
+
+import request from '@/lib/requests';
+import type {
+  CreateTaskRequest,
+  CreateTaskResponse,
+  TaskStatusResponse,
+} from '@repo/types/task';
+
+export async function createTask(task: CreateTaskRequest) {
+  return request.post<CreateTaskResponse>('/v1/task/create', {
+    params: task,
+  });
+}
+
+export async function getTaskStatus(taskId: string) {
+  return request.get<TaskStatusResponse>(`/v1/task/status/${taskId}`, {
+    cacheTime: 0,
+  });
+}

package/template/apps/web/lib/agent/chat-client.ts

@@ -0,0 +1,42 @@
+import OpenAI from 'openai';
+
+const openai = new OpenAI({
+  baseURL: process.env.NEXT_PUBLIC_AI_BASE_URL,
+  apiKey: 'dummy-key',
+  dangerouslyAllowBrowser: true,
+});
+
+interface ChatMessage {
+  role: 'system' | 'user' | 'assistant';
+  content: string;
+}
+
+export async function sendChatMessage(
+  messages: ChatMessage[],
+  onChunk?: (text: string) => void,
+): Promise<string> {
+  if (onChunk) {
+    const stream = await openai.chat.completions.create({
+      model: 'gpt-4',
+      messages,
+      stream: true,
+    });
+
+    let fullText = '';
+    for await (const chunk of stream) {
+      const content = chunk.choices[0]?.delta?.content || '';
+      if (content) {
+        fullText += content;
+        onChunk(content);
+      }
+    }
+    return fullText;
+  }
+
+  const response = await openai.chat.completions.create({
+    model: 'gpt-4',
+    messages,
+  });
+
+  return response.choices[0]?.message?.content || '';
+}

package/template/apps/web/lib/agent/prompts.ts

@@ -0,0 +1,43 @@
+export function createAgentPrompt(
+  locale: string,
+  question: string,
+  culturalContext: string,
+) {
+  const prompts = {
+    zh: `你是一位友好的中国文化导师，专门帮助外国人理解中国文化。
+
+今日话题：${question}
+
+文化背景：
+${culturalContext}
+
+对话规则：
+1. 只讨论今日话题相关的中国文化内容
+2. 用简单易懂的语言解释文化现象
+3. 可以分享相关的历史故事、现代实践、地区差异
+4. 如果用户问题偏离主题，礼貌地引导回今日话题
+5. 保持友好、耐心的态度
+
+引导话术（当用户偏题时）：
+"这是个有趣的问题！不过今天我们主要聊的是「${question}」相关的话题。关于这个，你还有什么想了解的吗？"`,
+
+    en: `You are a friendly Chinese culture tutor helping foreigners understand Chinese culture.
+
+Today's Topic: ${question}
+
+Cultural Background:
+${culturalContext}
+
+Conversation Rules:
+1. Only discuss Chinese culture related to today's topic
+2. Explain cultural phenomena in simple, understandable language
+3. Share relevant historical stories, modern practices, and regional differences
+4. If the user's question deviates from the topic, politely guide them back
+5. Maintain a friendly and patient attitude
+
+Redirect Phrase (when user goes off-topic):
+"That's an interesting question! However, today we're focusing on topics related to '${question}'. Is there anything else you'd like to know about this?"`,
+  };
+
+  return prompts[locale as keyof typeof prompts] || prompts.en;
+}

package/template/apps/web/lib/analytics/components/PageTracker.tsx

@@ -0,0 +1,137 @@
+/**
+ * PageTracker Component
+ * 页面追踪组件 - 用于在 Layout 层级自动追踪页面浏览
+ *
+ * Usage:
+ * ```tsx
+ * // In layout.tsx
+ * export default function RootLayout({ children }) {
+ *   return (
+ *     <html>
+ *       <body>
+ *         <PageTracker />
+ *         {children}
+ *       </body>
+ *     </html>
+ *   );
+ * }
+ * ```
+ */
+
+'use client';
+
+import { useEffect } from 'react';
+import { usePathname, useSearchParams } from 'next/navigation';
+import { analytics } from '../index';
+
+interface PageTrackerProps {
+  /**
+   * Whether to track search params changes
+   */
+  trackSearchParams?: boolean;
+
+  /**
+   * Custom page name mapper
+   */
+  pageNameMapper?: (pathname: string) => string;
+
+  /**
+   * Paths to exclude from tracking
+   */
+  excludePaths?: string[];
+}
+
+export function PageTracker({
+  trackSearchParams = true,
+  pageNameMapper,
+  excludePaths = [],
+}: PageTrackerProps = {}) {
+  const pathname = usePathname();
+  const searchParams = useSearchParams();
+
+  useEffect(() => {
+    // Check if path should be excluded
+    if (excludePaths.some((path) => pathname.startsWith(path))) {
+      return;
+    }
+
+    // Build full path with search params if enabled
+    const fullPath = trackSearchParams && searchParams.toString()
+      ? `${pathname}?${searchParams.toString()}`
+      : pathname;
+
+    // Get page name (custom or pathname)
+    const pageName = pageNameMapper ? pageNameMapper(pathname) : pathname;
+
+    // Track page view
+    analytics.pageView(fullPath, pageName);
+
+    // Track session start on first page view
+    if (typeof window !== 'undefined' && !sessionStorage.getItem('session_started')) {
+      analytics.track('SESSION_START', {
+        path: fullPath,
+      } as any);
+      sessionStorage.setItem('session_started', 'true');
+    }
+  }, [pathname, searchParams, trackSearchParams, pageNameMapper, excludePaths]);
+
+  // Track session end on page unload
+  useEffect(() => {
+    const handleBeforeUnload = () => {
+      analytics.track('SESSION_END', {
+        path: pathname,
+      } as any);
+    };
+
+    window.addEventListener('beforeunload', handleBeforeUnload);
+
+    return () => {
+      window.removeEventListener('beforeunload', handleBeforeUnload);
+    };
+  }, [pathname]);
+
+  // Track app visibility changes (background/foreground)
+  useEffect(() => {
+    const handleVisibilityChange = () => {
+      if (document.hidden) {
+        analytics.track('APP_BACKGROUND', {
+          path: pathname,
+        } as any);
+      } else {
+        analytics.track('APP_FOREGROUND', {
+          path: pathname,
+        } as any);
+      }
+    };
+
+    document.addEventListener('visibilitychange', handleVisibilityChange);
+
+    return () => {
+      document.removeEventListener('visibilitychange', handleVisibilityChange);
+    };
+  }, [pathname]);
+
+  return null;
+}
+
+/**
+ * Page name mapper for common routes
+ */
+export const defaultPageNameMapper = (pathname: string): string => {
+  const routes: Record<string, string> = {
+    '/': 'Home',
+    '/home': 'Home',
+    '/daily-challenge': 'Daily Challenge',
+    '/daily-challenge/result': 'Challenge Result',
+    '/daily-challenge/history': 'Challenge History',
+    '/settings': 'Settings',
+    '/login': 'Login',
+    '/register': 'Register',
+    '/upload': 'Upload',
+  };
+
+  // Remove locale prefix if present
+  const cleanPath = pathname.replace(/^\/[a-z]{2}(-[A-Z]{2})?/, '');
+
+  return routes[cleanPath] || cleanPath;
+};

package/template/apps/web/lib/analytics/hooks/usePageTracking.ts

@@ -0,0 +1,137 @@
+/**
+ * usePageTracking Hook
+ * 自动追踪页面浏览事件的 React Hook
+ *
+ * Usage:
+ * ```tsx
+ * // Basic usage - auto-tracks page view on mount
+ * usePageTracking();
+ *
+ * // With custom properties
+ * usePageTracking({
+ *   pageName: 'Daily Challenge',
+ *   category: 'engagement',
+ *   metadata: { questionId: 'xxx' }
+ * });
+ *
+ * // With dependencies - re-track when dependencies change
+ * usePageTracking({ pageName: 'Question Detail' }, [questionId]);
+ * ```
+ */
+
+import { useEffect, useRef } from 'react';
+import { usePathname } from 'next/navigation';
+import { analytics } from '../index';
+
+interface PageTrackingOptions {
+  /**
+   * Custom page name (defaults to pathname)
+   */
+  pageName?: string;
+
+  /**
+   * Page category for grouping
+   */
+  category?: string;
+
+  /**
+   * Additional metadata to track
+   */
+  metadata?: Record<string, any>;
+
+  /**
+   * Whether to track on mount (default: true)
+   */
+  trackOnMount?: boolean;
+
+  /**
+   * Custom page title (defaults to document.title)
+   */
+  title?: string;
+}
+
+/**
+ * Hook to automatically track page views
+ */
+export function usePageTracking(
+  options: PageTrackingOptions = {},
+  dependencies: any[] = [],
+) {
+  const pathname = usePathname();
+  const {
+    pageName,
+    category,
+    metadata,
+    trackOnMount = true,
+    title,
+  } = options;
+
+  // Track if we've already tracked this page view
+  const hasTracked = useRef(false);
+
+  useEffect(() => {
+    // Only track if enabled and not already tracked (or dependencies changed)
+    if (!trackOnMount && hasTracked.current) return;
+
+    const path = pageName || pathname;
+    const pageTitle = title || (typeof document !== 'undefined' ? document.title : undefined);
+
+    // Track page view with enriched properties
+    analytics.pageView(path, pageTitle);
+
+    // Track additional metadata if provided
+    if (category || metadata) {
+      analytics.track('PAGE_VIEW', {
+        path,
+        title: pageTitle,
+        category,
+        ...metadata,
+      } as any);
+    }
+
+    hasTracked.current = true;
+
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [pathname, pageName, category, title, trackOnMount, ...dependencies]);
+}
+
+/**
+ * Hook to track page section views (for single-page apps with sections)
+ */
+export function useSectionTracking(
+  sectionName: string,
+  options: Omit<PageTrackingOptions, 'pageName'> = {},
+) {
+  usePageTracking(
+    {
+      ...options,
+      pageName: sectionName,
+    },
+    [sectionName],
+  );
+}
+
+/**
+ * Hook to manually trigger page tracking
+ */
+export function useManualPageTracking() {
+  const pathname = usePathname();
+
+  return {
+    trackPage: (options: PageTrackingOptions = {}) => {
+      const path = options.pageName || pathname;
+      const pageTitle = options.title || (typeof document !== 'undefined' ? document.title : undefined);
+
+      analytics.pageView(path, pageTitle);
+
+      if (options.category || options.metadata) {
+        analytics.track('PAGE_VIEW', {
+          path,
+          title: pageTitle,
+          category: options.category,
+          ...options.metadata,
+        } as any);
+      }
+    },
+  };
+}

package/template/apps/web/lib/analytics/index.ts

@@ -0,0 +1,180 @@
+/**
+ * Analytics Tracking Utility
+ * 前端事件追踪工具
+ *
+ * Usage:
+ * ```ts
+ * import { analytics } from '@/lib/analytics';
+ *
+ * // Track a single event
+ * // Track page view
+ * analytics.pageView('/dashboard');
+ * ```
+ */
+
+import type { AnalyticsEventType, EventProperties } from '@repo/contracts';
+import { tsRestClient } from '@/lib/api/contracts/client';
+
+class Analytics {
+  private sessionId: string;
+  private eventQueue: Array<{
+    event: AnalyticsEventType;
+    properties?: EventProperties;
+  }> = [];
+  private flushInterval: NodeJS.Timeout | null = null;
+  private readonly FLUSH_INTERVAL_MS = 5000; // Flush every 5 seconds
+  private readonly MAX_QUEUE_SIZE = 10; // Flush when queue reaches 10 events
+  private currentPage: string | null = null;
+  private pageStartTime: number | null = null;
+
+  constructor() {
+    this.sessionId = this.generateSessionId();
+    this.startAutoFlush();
+  }
+
+  /**
+   * Generate a unique session ID
+   */
+  private generateSessionId(): string {
+    return `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+  }
+
+  /**
+   * Get base event properties
+   */
+  private getBaseProperties(): Partial<EventProperties> {
+    return {
+      timestamp: Date.now(),
+      sessionId: this.sessionId,
+      locale: typeof window !== 'undefined' ? navigator.language : 'en',
+      platform: 'web',
+      userAgent:
+        typeof window !== 'undefined' ? navigator.userAgent : undefined,
+      referrer: typeof window !== 'undefined' ? document.referrer : undefined,
+      path: this.currentPage || undefined,
+    };
+  }
+
+  /**
+   * Set current page context
+   */
+  setPageContext(path: string) {
+    // Track time spent on previous page
+    if (this.currentPage && this.pageStartTime) {
+      const timeSpent = Date.now() - this.pageStartTime;
+      this.track('PAGE_VIEW', {
+        path: this.currentPage,
+        timeSpent: Math.floor(timeSpent / 1000), // Convert to seconds
+      } as EventProperties);
+    }
+
+    this.currentPage = path;
+    this.pageStartTime = Date.now();
+  }
+
+  /**
+   * Get current page context
+   */
+  getPageContext() {
+    return {
+      currentPage: this.currentPage,
+      timeOnPage: this.pageStartTime ? Date.now() - this.pageStartTime : 0,
+    };
+  }
+
+  /**
+   * Track a single event
+   */
+  track(event: AnalyticsEventType, properties?: Partial<EventProperties>) {
+    const enrichedProperties = {
+      ...this.getBaseProperties(),
+      ...properties,
+    };
+
+    this.eventQueue.push({
+      event,
+      properties: enrichedProperties as EventProperties,
+    });
+
+    // Flush immediately if queue is full
+    if (this.eventQueue.length >= this.MAX_QUEUE_SIZE) {
+      this.flush();
+    }
+  }
+
+  /**
+   * Track page view
+   */
+  pageView(path: string, title?: string) {
+    // Update page context
+    this.setPageContext(path);
+
+    this.track('PAGE_VIEW', {
+      path,
+      title:
+        title || (typeof document !== 'undefined' ? document.title : undefined),
+    } as EventProperties);
+  }
+
+  /**
+   * Flush events to backend
+   */
+  private async flush() {
+    if (this.eventQueue.length === 0) return;
+
+    const eventsToSend = [...this.eventQueue];
+    this.eventQueue = [];
+
+    try {
+      // Use ts-rest direct client to send events (imperative call, not hook)
+      const result = await tsRestClient.analyticsClient.trackBatch({
+        body: { events: eventsToSend },
+      });
+
+      if (result.status !== 200) {
+        console.error('Analytics API returned non-200 status:', result.status);
+      }
+    } catch (error) {
+      console.error('Failed to send analytics events:', error);
+      // Re-queue failed events (optional)
+      // this.eventQueue.unshift(...eventsToSend);
+    }
+  }
+
+  /**
+   * Start auto-flush interval
+   */
+  private startAutoFlush() {
+    if (typeof window === 'undefined') return;
+
+    this.flushInterval = setInterval(() => {
+      this.flush();
+    }, this.FLUSH_INTERVAL_MS);
+
+    // Flush on page unload
+    window.addEventListener('beforeunload', () => {
+      this.flush();
+    });
+  }
+
+  /**
+   * Stop auto-flush interval
+   */
+  stopAutoFlush() {
+    if (this.flushInterval) {
+      clearInterval(this.flushInterval);
+      this.flushInterval = null;
+    }
+  }
+}
+
+// Export singleton instance
+export const analytics = new Analytics();
+
+// Export hooks and components
+export {
+  usePageTracking,
+  useSectionTracking,
+  useManualPageTracking,
+} from './hooks/usePageTracking';
+export { PageTracker, defaultPageNameMapper } from './components/PageTracker';

package/template/apps/web/lib/api/agents.ts

@@ -0,0 +1,7 @@
+import request from '@/lib/requests';
+import type { AgentInfo } from '@repo/types/ai';
+
+// 获取智能体列表
+export const getAgentList = () => {
+  return request.get<AgentInfo[]>('/agents');
+};