work-agent 0.1.0

package/lib/pi-session.ts

@@ -0,0 +1,799 @@
+/**
+ * PI Agent Session Manager
+ *
+ * Manages pi-coding-agent sessions for intelligent operations.
+ * Handles session creation, configuration, and event streaming.
+ *
+ * Sessions are persisted to disk to survive server restarts and hot reloads.
+ */
+
+// 全局变量，用于在工具中获取当前会话ID
+let currentSessionId: string | null = null;
+
+export function getCurrentSessionId(): string | null {
+	return currentSessionId;
+}
+
+export function setCurrentSessionId(id: string | null): void {
+	currentSessionId = id;
+}
+
+import {
+	AuthStorage,
+	createAgentSession,
+	DefaultResourceLoader,
+	SessionManager,
+	SettingsManager,
+	createReadTool,
+	createEditTool,
+	createWriteTool,
+	createGrepTool,
+	createFindTool,
+	createLsTool,
+	type AgentSession,
+	type AgentSessionEvent,
+	type ToolDefinition,
+} from "@mariozechner/pi-coding-agent";
+
+export { AgentSessionEvent };
+import { writeFileSync, readFileSync, mkdirSync, existsSync } from "fs";
+import { join } from "path";
+import {
+	DEFAULT_PROVIDERS,
+	getAuthConfig,
+	getAvailableProviders,
+	getDefaultProvider,
+	loadModelsConfig,
+	PI_CONFIG_DIR,
+	type ProviderConfig,
+} from "./pi-config";
+import { createSecureBashTool } from "./secure-bash-tool";
+import { createTicketTool } from "./ticket-tool";
+import { createScheduledTaskTool } from "./scheduled-task-tool";
+import { createSkillTool } from "./skill-tool";
+import { saveKnowledgeTool } from "./knowledge-tool";
+import { createMemoryTool } from "./memory-tool";
+import { fileTools } from "./file-tool";
+import { loadUserMemories } from "./memory";
+import { getActiveKnowledge, searchKnowledge, saveSession as dbSaveSession, getSession as dbGetSession, getAllSessions as dbGetAllSessions, deleteSession as dbDeleteSession, getDb } from "./db";
+import {
+	getUserAvailableSkills,
+	loadSkillFromPath,
+	loadSkillMetaFromPath,
+	type SkillLocation,
+} from './skill-loader';
+
+// Session directory for persistence (our metadata)
+const SESSION_DIR = join(process.cwd(), "data", "sessions");
+
+// Session directory for pi-coding-agent (JSONL files)
+const PI_SESSIONS_DIR = join(process.cwd(), "data", "pi-sessions");
+
+// Ensure session directory exists
+if (!existsSync(SESSION_DIR)) {
+	try {
+		mkdirSync(SESSION_DIR, { recursive: true });
+	} catch (error) {
+		// Directory may already exist, ignore
+	}
+}
+
+// Ensure pi-sessions directory exists
+if (!existsSync(PI_SESSIONS_DIR)) {
+	try {
+		mkdirSync(PI_SESSIONS_DIR, { recursive: true });
+	} catch (error) {
+		// Directory may already exist, ignore
+	}
+}
+
+// Session storage (in-memory for quick access, persisted to disk)
+const activeSessions = new Map<string, AgentSession>();
+
+// Session metadata storage (for tracking sessions across restarts)
+interface SessionMetadata {
+	sessionId: string;
+	userId?: string;
+	source?: 'web' | 'feishu_bot' | 'api';
+	sourceUserId?: string;
+	createdAt: string;
+	lastAccessedAt: string;
+	messageCount: number;
+	recentSummary?: string;
+	title?: string;
+}
+
+const sessionMetadata = new Map<string, SessionMetadata>();
+
+/**
+ * Configuration for PI agent session
+ */
+interface PiSessionConfig {
+	userId?: string;
+	source?: 'web' | 'feishu_bot' | 'api';
+	sourceUserId?: string;
+	systemPrompt?: string;
+	model?: string;
+	providerId?: string;
+	skills?: string[];
+	sessionId?: string;
+}
+
+/**
+ * Get session metadata file path
+ */
+function getSessionMetadataPath(sessionId: string): string {
+	return join(SESSION_DIR, `${sessionId}.json`);
+}
+
+/**
+ * Save session metadata to database
+ */
+function saveSessionMetadata(metadata: SessionMetadata): void {
+	try {
+		dbSaveSession({
+			sessionId: metadata.sessionId,
+			userId: metadata.userId,
+			createdAt: metadata.createdAt,
+			lastAccessedAt: metadata.lastAccessedAt,
+			messageCount: metadata.messageCount,
+			recentSummary: metadata.recentSummary,
+			title: metadata.title,
+		});
+	} catch (error) {
+		console.error('Failed to save session metadata:', error);
+	}
+}
+
+/**
+ * Load session metadata from database
+ */
+function loadSessionMetadata(sessionId: string): SessionMetadata | null {
+	try {
+		const session = dbGetSession(sessionId);
+		if (!session) return null;
+		return {
+			sessionId: session.sessionId,
+			userId: session.userId,
+			source: session.source,
+			sourceUserId: session.sourceUserId,
+			createdAt: session.createdAt.toISOString(),
+			lastAccessedAt: session.lastAccessedAt.toISOString(),
+			messageCount: session.messageCount,
+			recentSummary: session.recentSummary,
+			title: session.title,
+		};
+	} catch (error) {
+		console.error('Failed to load session metadata:', error);
+		return null;
+	}
+}
+
+/**
+ * Get or create a PI agent session
+ */
+export async function getOrCreateSession(
+	sessionId: string,
+	config: PiSessionConfig = {},
+): Promise<{ session: AgentSession; isNew: boolean; restored?: boolean }> {
+	// Check if session exists in memory
+	const existing = activeSessions.get(sessionId);
+	if (existing) {
+		// Update last accessed time
+		const metadata = sessionMetadata.get(sessionId);
+		if (metadata) {
+			metadata.lastAccessedAt = new Date().toISOString();
+			saveSessionMetadata(metadata);
+		}
+		return { session: existing, isNew: false };
+	}
+
+	// Check if session exists on disk (restoring after restart)
+	const existingMetadata = loadSessionMetadata(sessionId);
+	if (existingMetadata) {
+		// Restore session with previous context
+		// Pass sessionId to enable persistence - pi-coding-agent will load history from file
+		const session = await createPiSession({
+			...config,
+			sessionId, // Important: pass sessionId for persistence
+			userId: existingMetadata.userId || config.userId,
+		});
+		activeSessions.set(sessionId, session);
+
+		// Update metadata
+		existingMetadata.lastAccessedAt = new Date().toISOString();
+		sessionMetadata.set(sessionId, existingMetadata);
+		saveSessionMetadata(existingMetadata);
+
+		return { session, isNew: false, restored: true };
+	}
+
+	// Create new session
+	// Pass sessionId to enable persistence
+	const session = await createPiSession({
+		...config,
+		sessionId, // Important: pass sessionId for persistence
+	});
+	activeSessions.set(sessionId, session);
+
+	// Save metadata
+	const metadata: SessionMetadata = {
+		sessionId,
+		userId: config.userId,
+		source: config.source,
+		sourceUserId: config.sourceUserId,
+		createdAt: new Date().toISOString(),
+		lastAccessedAt: new Date().toISOString(),
+		messageCount: 0,
+	};
+	sessionMetadata.set(sessionId, metadata);
+	saveSessionMetadata(metadata);
+
+	return { session, isNew: true };
+}
+
+/**
+ * Update session summary (call after each message to maintain context)
+ */
+export function updateSessionSummary(sessionId: string, summary: string): void {
+	const metadata = sessionMetadata.get(sessionId);
+	if (metadata) {
+		metadata.recentSummary = summary;
+		saveSessionMetadata(metadata);
+	}
+}
+
+/**
+ * Get the session file path for pi-coding-agent (JSONL format)
+ */
+function getPiSessionFilePath(sessionId: string): string {
+	return join(PI_SESSIONS_DIR, `${sessionId}.jsonl`);
+}
+
+/**
+ * 检查用户是否是管理员
+ */
+function checkIsAdmin(userId: string): boolean {
+	try {
+		const db = getDb();
+		const user = db.prepare('SELECT role FROM users WHERE id = ?').get(userId) as { role: string } | undefined;
+		return user?.role === 'admin';
+	} catch (error) {
+		console.error('[pi-session] Failed to check admin status:', error);
+		return false;
+	}
+}
+
+/**
+ * Create a new PI agent session with tools
+ */
+async function createPiSession(config: PiSessionConfig): Promise<AgentSession> {
+	const { userId, systemPrompt, model, providerId, skills = [], sessionId } = config;
+
+	// 检查用户是否是管理员
+	const isAdmin = userId ? checkIsAdmin(userId) : false;
+	console.log('[pi-session] User:', userId, 'isAdmin:', isAdmin);
+
+	// Load skill content
+	let skillsContent = '';
+	if (skills.length > 0) {
+		const skillContents: string[] = [];
+
+		// 使用新的技能加载器
+		const availableSkills = getUserAvailableSkills(userId);
+
+		for (const skillName of skills) {
+			const location = availableSkills.get(skillName);
+			if (location) {
+				try {
+					const content = loadSkillFromPath(location.path);
+					if (content) {
+						skillContents.push(content);
+						const sourceLabel = location.source === 'system' ? '系统' :
+										   location.source === 'user' ? '用户' : '市场';
+						console.log(`[pi-session] Loaded ${sourceLabel} skill: ${skillName} from ${location.path}`);
+					}
+				} catch (error) {
+					console.error(`[pi-session] Failed to load skill ${skillName}:`, error);
+				}
+			} else {
+				console.warn(`[pi-session] Skill not found: ${skillName}`);
+			}
+		}
+
+		if (skillContents.length > 0) {
+			skillsContent = skillContents.join('\n\n---\n\n');
+		}
+	}
+
+	// Load configuration from models.json
+	const providers = getAvailableProviders();
+	const defaultProvider = getDefaultProvider();
+
+	// Use selected provider or default
+	const selectedProvider = providerId
+		? providers.find(p => p.id === providerId) || defaultProvider
+		: defaultProvider;
+
+	// Set up auth storage
+	const authStorage = AuthStorage.inMemory();
+
+	// Support AI_ prefix environment variables (works with or without models.json)
+	const aiProvider = process.env.AI_PROVIDER;
+	const aiApiKey = process.env.AI_API_KEY;
+	const aiModel = process.env.AI_MODEL;
+	const aiBaseUrl = process.env.AI_BASE_URL;
+
+	// If AI_ environment variables are set, use them directly
+	if (aiProvider && aiApiKey) {
+		const providerId = aiProvider.toLowerCase();
+		const defaultProvider = DEFAULT_PROVIDERS[providerId];
+
+		authStorage.setRuntimeApiKey(providerId, aiApiKey);
+
+		console.log(`[pi-session] Using AI_ environment variables:`);
+		console.log(`[pi-session]   AI_PROVIDER: ${providerId}`);
+		console.log(`[pi-session]   AI_MODEL: ${aiModel || defaultProvider?.models?.[0]?.id || 'default'}`);
+		if (aiBaseUrl) {
+			console.log(`[pi-session]   AI_BASE_URL: ${aiBaseUrl}`);
+		}
+		console.log(`[pi-session]   AI_API_KEY: ${aiApiKey.substring(0, 10)}...`);
+	} else if (selectedProvider) {
+		// Set API key from models.json
+		authStorage.setRuntimeApiKey(selectedProvider.id, selectedProvider.apiKey);
+
+		console.log(`[pi-session] Using provider from models.json: ${selectedProvider.name} (${selectedProvider.id})`);
+		console.log(`[pi-session]   API type: ${selectedProvider.api}`);
+		if (selectedProvider.baseUrl) {
+			console.log(`[pi-session]   Base URL: ${selectedProvider.baseUrl}`);
+		}
+		console.log(`[pi-session]   Config dir: ${PI_CONFIG_DIR}`);
+		console.log(`[pi-session]   HOME env: ${process.env.HOME || 'not set'}`);
+		console.log(`[pi-session]   CWD: ${process.cwd()}`);
+		// Debug: show API key (first 10 and last 10 chars)
+		const key = selectedProvider.apiKey;
+		const maskedKey = key.length > 20 ? `${key.substring(0, 10)}...${key.substring(key.length - 10)}` : key;
+		console.log(`[pi-session]   API Key (debug): ${maskedKey}`);
+		console.log(`[pi-session]   API Key length: ${key.length}`);
+	}
+
+	// Check if we have any auth configured
+	if (!aiProvider && !aiApiKey && !selectedProvider) {
+		throw new Error(
+			'No AI provider configured. Please either:\n' +
+			'1. Set PI_CONFIG_PATH to your models.json location\n' +
+			'2. Mount ~/.pi/agent to the container\n' +
+			'3. Set AI_PROVIDER and AI_API_KEY environment variables\n' +
+			`Config directory: ${PI_CONFIG_DIR}`
+		);
+	}
+
+	// In-memory settings with overrides
+	const settingsManager = SettingsManager.inMemory({
+		compaction: { enabled: false }, // Disable auto-compaction for web use
+		retry: { enabled: true, maxRetries: 2 },
+	});
+
+	// Load user memories
+	const userMemories = userId ? loadUserMemories(userId) : '';
+
+	// Custom system prompt for general-purpose AI assistant
+	const defaultSystemPrompt = systemPrompt || `You are a helpful AI Assistant with command execution capabilities.
+
+${skillsContent ? `
+## User Activated Skills
+
+The user has explicitly activated the following skill(s). Follow their instructions when processing user requests related to these skills:
+
+---
+${skillsContent}
+---
+` : ''}
+
+${userMemories ? `
+## User Memories
+
+The following are the user's saved memories from previous conversations. Please reference this information when helping the user:
+
+---
+${userMemories}
+---
+
+**IMPORTANT:** When the user asks you to "remember" or "note" something, use the \`save_memory\` tool to save it to their memories.
+` : `
+**Memory:** If the user asks you to "remember" something important, use the \`save_memory\` tool to save it for future reference.`}
+
+**Your Capabilities:**
+- Execute shell commands using the bash tool
+- Read, write, and edit files
+- Search for files and content
+- Create operation tickets for dangerous commands
+- Save memories for the user using the save_memory tool
+
+**CRITICAL SECURITY RULES:**
+1. Dangerous commands (file deletions, system modifications, etc.) are BLOCKED and will NOT execute
+2. When you need to perform a dangerous operation, you MUST use the \`create_ticket\` tool to create a ticket
+3. Tickets require human approval before execution - always inform users about this
+4. Safe commands (ls, cat, grep, etc.) can be executed directly
+
+**How to Create Tickets:**
+Use the \`create_ticket\` tool with the command you want to execute:
+\`\`\`
+create_ticket(command="your-command-here", title="操作标题", description="...")
+\`\`\`
+
+**Available Tools:**
+- bash: Execute shell commands (dangerous commands are BLOCKED)
+- read: Read file contents
+- edit: Edit existing files
+- write: Create new files
+- grep: Search file contents
+- find: Find files by pattern
+- ls: List directory contents
+- create_ticket: Create an operation ticket for approval workflow (USE THIS for dangerous commands!)
+
+${userId ? `**Current User:** ${userId}` : ""}
+
+Start by greeting the user and asking how you can help them.`;
+
+	// Create resource loader with custom system prompt
+	const loader = new DefaultResourceLoader({
+		cwd: process.cwd(),
+		systemPromptOverride: () => defaultSystemPrompt,
+		settingsManager,
+	});
+	await loader.reload();
+
+	// Create custom tools
+	// 1. Secure bash tool - intercepts dangerous commands and creates tickets
+	//    传入 userId 和 isAdmin，用于权限控制（非管理员只能执行远程命令）
+	const secureBashTool = createSecureBashTool(process.cwd(), userId, isAdmin);
+
+	// 2. Standard coding tools (read, edit, write, grep, find, ls)
+	const customToolSet = [
+		createReadTool(process.cwd()),
+		secureBashTool,  // Our secure bash tool
+		createEditTool(process.cwd()),
+		createWriteTool(process.cwd()),
+		createGrepTool(process.cwd()),
+		createFindTool(process.cwd()),
+		createLsTool(process.cwd()),
+	];
+
+	// Create or open the SessionManager for persistence
+	let sessionManager: SessionManager;
+	if (sessionId) {
+		const sessionFile = getPiSessionFilePath(sessionId);
+		if (existsSync(sessionFile)) {
+			// Open existing session to restore history
+			sessionManager = SessionManager.open(sessionFile, PI_SESSIONS_DIR);
+			console.log(`[pi-session] Opened existing session: ${sessionId}`);
+		} else {
+			// Create new session with persistence
+			sessionManager = SessionManager.create(process.cwd(), PI_SESSIONS_DIR);
+			// Set the session file path to use our custom naming
+			sessionManager.setSessionFile(sessionFile);
+			console.log(`[pi-session] Created new persistent session: ${sessionId}`);
+		}
+	} else {
+		// Fallback to in-memory if no sessionId provided
+		sessionManager = SessionManager.inMemory();
+		console.log('[pi-session] Using in-memory session (no sessionId provided)');
+	}
+
+	// 设置当前会话ID，供工具使用
+	setCurrentSessionId(sessionId || null);
+
+	// Create the session
+	// Pass agentDir to ensure ModelRegistry loads from the correct location
+	console.log('[pi-session] Creating agent session...');
+	console.log('[pi-session]   cwd:', process.cwd());
+	console.log('[pi-session]   agentDir:', PI_CONFIG_DIR);
+	console.log('[pi-session]   selectedProvider.id:', selectedProvider?.id);
+	console.log('[pi-session]   selectedProvider.baseUrl:', selectedProvider?.baseUrl);
+	console.log('[pi-session]   selectedProvider.api:', selectedProvider?.api);
+
+	const result = await createAgentSession({
+		cwd: process.cwd(),
+		agentDir: PI_CONFIG_DIR, // Use our config directory for models.json
+		authStorage,
+		sessionManager,
+		settingsManager,
+		resourceLoader: loader,
+		customTools: [
+			createTicketTool as unknown as ToolDefinition,
+			createScheduledTaskTool as unknown as ToolDefinition,
+			createSkillTool(userId) as unknown as ToolDefinition,
+			saveKnowledgeTool as unknown as ToolDefinition,
+			createMemoryTool(userId) as unknown as ToolDefinition,
+			...fileTools.map(t => t as unknown as ToolDefinition),
+		], // Add custom tools
+	});
+
+	// IMPORTANT: Override the default tools with our custom tools
+	// The SDK's `tools` parameter only extracts tool names and uses default tools,
+	// so we need to manually set our secure tools after session creation.
+	// We must include ALL tools here, including the create_ticket from customTools.
+	console.log('[pi-session] Setting custom tools with secure bash and create_ticket...');
+
+	// Get the tools that were registered by customTools
+	const existingTools = result.session.agent.state.tools;
+	const createTicketExistingTool = existingTools.find((t: any) => t.name === 'create_ticket');
+	const createScheduledTaskExistingTool = existingTools.find((t: any) => t.name === 'create_scheduled_task');
+	const createSkillExistingTool = existingTools.find((t: any) => t.name === 'create_skill');
+	const saveKnowledgeExistingTool = existingTools.find((t: any) => t.name === 'save_knowledge');
+	const saveMemoryExistingTool = existingTools.find((t: any) => t.name === 'save_memory');
+	const listFilesTool = existingTools.find((t: any) => t.name === 'list_user_files');
+	const getFileInfoTool = existingTools.find((t: any) => t.name === 'get_file_info');
+	const downloadFileTool = existingTools.find((t: any) => t.name === 'download_file');
+	const uploadFileTool = existingTools.find((t: any) => t.name === 'upload_file');
+	const deleteFileTool = existingTools.find((t: any) => t.name === 'delete_file');
+	const updateFileInfoTool = existingTools.find((t: any) => t.name === 'update_file_info');
+
+	// Combine our custom bash tool with other tools and custom tools
+	const allTools = [
+		...customToolSet,
+		...(createTicketExistingTool ? [createTicketExistingTool] : []),
+		...(createScheduledTaskExistingTool ? [createScheduledTaskExistingTool] : []),
+		...(createSkillExistingTool ? [createSkillExistingTool] : []),
+		...(saveKnowledgeExistingTool ? [saveKnowledgeExistingTool] : []),
+		...(saveMemoryExistingTool ? [saveMemoryExistingTool] : []),
+		...(listFilesTool ? [listFilesTool] : []),
+		...(getFileInfoTool ? [getFileInfoTool] : []),
+		...(downloadFileTool ? [downloadFileTool] : []),
+		...(uploadFileTool ? [uploadFileTool] : []),
+		...(deleteFileTool ? [deleteFileTool] : []),
+		...(updateFileInfoTool ? [updateFileInfoTool] : []),
+	];
+
+	result.session.agent.setTools(allTools);
+
+	return result.session;
+}
+
+/**
+ * Convert PI session events to SSE format for web streaming
+ */
+export function eventToSSE(event: AgentSessionEvent): string | null {
+	switch (event.type) {
+		case "message_update":
+			if (event.assistantMessageEvent.type === "text_delta") {
+				return `data: ${JSON.stringify({ type: "text", content: event.assistantMessageEvent.delta })}\n\n`;
+			}
+			if (event.assistantMessageEvent.type === "thinking_delta") {
+				return `data: ${JSON.stringify({ type: "thinking", content: event.assistantMessageEvent.delta })}\n\n`;
+			}
+			break;
+
+		case "tool_execution_start":
+			return `data: ${JSON.stringify({ type: "tool_start", toolName: event.toolName, args: event.args })}\n\n`;
+
+		case "tool_execution_update":
+			// partialResult contains the tool output
+			return `data: ${JSON.stringify({ type: "tool_output", toolName: event.toolName, content: JSON.stringify(event.partialResult) })}\n\n`;
+
+		case "tool_execution_end":
+			return `data: ${JSON.stringify({ type: "tool_end", toolName: event.toolName, isError: event.isError })}\n\n`;
+
+		case "message_end":
+			return `data: ${JSON.stringify({ type: "message_end", message: event.message })}\n\n`;
+
+		case "agent_end":
+			return `data: ${JSON.stringify({ type: "agent_end", messages: event.messages })}\n\n`;
+
+		case "turn_start":
+			return `data: ${JSON.stringify({ type: "turn_start" })}\n\n`;
+
+		case "turn_end":
+			return `data: ${JSON.stringify({ type: "turn_end", message: event.message, toolResults: event.toolResults })}\n\n`;
+
+		default:
+			// Log unhandled events for debugging
+			console.log('[pi-session] Unhandled event type:', event.type, event);
+			return null;
+	}
+
+	return null;
+}
+
+/**
+ * Abort current operation in a session
+ */
+export async function abortSession(sessionId: string): Promise<void> {
+	const session = activeSessions.get(sessionId);
+	if (session) {
+		try {
+			await session.abort();
+			console.log(`[pi-session] Aborted session: ${sessionId}`);
+		} catch (error) {
+			console.error(`[pi-session] Abort error for ${sessionId}:`, error);
+			throw error;
+		}
+	}
+}
+
+/**
+ * Clean up a session (call when user leaves or session expires)
+ */
+export function cleanupSession(sessionId: string): void {
+	const session = activeSessions.get(sessionId);
+	if (session) {
+		session.dispose();
+		activeSessions.delete(sessionId);
+	}
+	// Also remove metadata
+	sessionMetadata.delete(sessionId);
+	// Delete from database
+	try {
+		dbDeleteSession(sessionId);
+	} catch (error) {
+		console.error('Failed to delete session from database:', error);
+	}
+}
+
+/**
+ * Get all active sessions (for debugging/monitoring)
+ */
+export function getActiveSessions(): string[] {
+	return Array.from(activeSessions.keys());
+}
+
+/**
+ * Check if a session exists
+ */
+export function hasSession(sessionId: string): boolean {
+	return activeSessions.has(sessionId);
+}
+
+/**
+ * Get all persisted session IDs (including inactive ones)
+ */
+export function getAllSessionIds(): string[] {
+	try {
+		const sessions = dbGetAllSessions();
+		return sessions.map(s => s.sessionId);
+	} catch (error) {
+		return [];
+	}
+}
+
+/**
+ * Get all session metadata
+ */
+export function getAllSessionMetadata(): SessionMetadata[] {
+	try {
+		const sessions = dbGetAllSessions();
+		return sessions.map(s => ({
+			sessionId: s.sessionId,
+			userId: s.userId,
+			createdAt: s.createdAt.toISOString(),
+			lastAccessedAt: s.lastAccessedAt.toISOString(),
+			messageCount: s.messageCount,
+			recentSummary: s.recentSummary,
+			title: s.title,
+		}));
+	} catch (error) {
+		console.error('Failed to get all session metadata:', error);
+		return [];
+	}
+}
+
+/**
+ * Get session metadata by ID
+ */
+export function getSessionMetadata(sessionId: string): SessionMetadata | null {
+	return loadSessionMetadata(sessionId);
+}
+
+// ==================== 动态加载函数 ====================
+
+/**
+ * 动态加载单个 Skill 的内容
+ */
+export function loadSkillContent(skillName: string): string | null {
+	const skillPath = join(process.cwd(), '.pi', 'skills', skillName, 'SKILL.md');
+	
+	if (!existsSync(skillPath)) {
+		console.warn(`[pi-session] Skill not found: ${skillName}`);
+		return null;
+	}
+	
+	try {
+		const content = readFileSync(skillPath, 'utf-8');
+		console.log(`[pi-session] Dynamically loaded skill: ${skillName}`);
+		return content;
+	} catch (error) {
+		console.error(`[pi-session] Failed to load skill ${skillName}:`, error);
+		return null;
+	}
+}
+
+/**
+ * 搜索知识库并返回匹配的知识内容
+ */
+export function searchKnowledgeContent(keywords: string, limit: number = 5): string {
+	try {
+		const results = searchKnowledge(keywords, limit);
+		if (results.length === 0) {
+			return '';
+		}
+		
+		const knowledgeContent = results.map(k =>
+			`### ${k.title}\n\n${k.content}`
+		).join('\n\n---\n\n');
+		
+		console.log(`[pi-session] Searched knowledge with "${keywords}", found ${results.length} items`);
+		return knowledgeContent;
+	} catch (error) {
+		console.error('[pi-session] Failed to search knowledge:', error);
+		return '';
+	}
+}
+
+// ==================== 迁移函数 ====================
+
+let sessionsMigrated = false;
+
+/**
+ * 从文件迁移会话列表到数据库（一次性）
+ */
+export function migrateSessionsFromFiles(): void {
+	if (sessionsMigrated) {
+		return;
+	}
+
+	try {
+		const { readdirSync, existsSync, readFileSync } = require('fs');
+		
+		if (!existsSync(SESSION_DIR)) {
+			console.log('[pi-session] No sessions directory found, skipping migration');
+			sessionsMigrated = true;
+			return;
+		}
+
+		const files = readdirSync(SESSION_DIR);
+		const sessionFiles = files.filter((f: string) => f.endsWith('.json'));
+
+		if (sessionFiles.length === 0) {
+			console.log('[pi-session] No session files found, skipping migration');
+			sessionsMigrated = true;
+			return;
+		}
+
+		console.log(`[pi-session] Migrating ${sessionFiles.length} sessions from files to database...`);
+
+		let migrated = 0;
+		for (const file of sessionFiles) {
+			const sessionId = file.replace('.json', '');
+			
+			// Skip if already in database
+			const existing = dbGetSession(sessionId);
+			if (existing) {
+				continue;
+			}
+
+			try {
+				const path = join(SESSION_DIR, file);
+				const data = readFileSync(path, 'utf-8');
+				const metadata = JSON.parse(data) as SessionMetadata;
+
+				dbSaveSession({
+					sessionId: metadata.sessionId,
+					userId: metadata.userId,
+					createdAt: metadata.createdAt,
+					lastAccessedAt: metadata.lastAccessedAt,
+					messageCount: metadata.messageCount,
+					recentSummary: metadata.recentSummary,
+				});
+				migrated++;
+			} catch (error) {
+				console.warn(`[pi-session] Failed to migrate session ${sessionId}:`, error);
+			}
+		}
+
+		console.log(`[pi-session] Migrated ${migrated} sessions to database`);
+		sessionsMigrated = true;
+	} catch (error) {
+		console.error('[pi-session] Migration failed:', error);
+	}
+}