@myassis/gateway 1.0.0

package/dist/services/memory/MemoryManager.js

@@ -0,0 +1,117 @@
+import { getLogger } from '@pocketclaw/shared';
+const logger = getLogger('MemoryManager');
+import { toModel } from '../models';
+import { modelsService } from '../dataService';
+import { LLMClient } from '../llm/LLMClient';
+import { appConfig } from '@/config';
+const DEFAULT_CONFIG = {
+    summaryThreshold: 10,
+    enabled: true,
+};
+/**
+ * 记忆管理器
+ * 实现总结式记忆：当对话超过一定长度时，自动生成对话摘要
+ */
+export class MemoryManager {
+    session;
+    signal;
+    config = DEFAULT_CONFIG;
+    constructor(session, signal) {
+        this.session = session;
+        this.signal = signal;
+    }
+    toSummaryMessage(summary, createdAt, modelName) {
+        return {
+            sessionId: this.session.id,
+            content: `对话内容摘要：\n${summary}`,
+            role: 'system',
+            id: `summary_${createdAt}`,
+            createdAt,
+            modelName,
+        };
+    }
+    async getHistoryMessagesAsync() {
+        // 1. 获取所有消息
+        const messages = this.session.getMessages();
+        // 2. 消息少于摘要配置的阈值数，直接返回
+        logger.debug('message length:', messages.length);
+        if (messages.length < this.config.summaryThreshold) {
+            return messages;
+        }
+        // 3. 检查是否有摘要
+        const hasSummary = this.session.lastMessageSummary;
+        logger.debug('hasSummary', hasSummary);
+        if (!hasSummary) {
+            // 4A. 首次摘要生成
+            const summary = await this.generateSummaryAsync(messages.slice(0, -appConfig.messageKeep), null);
+            this.session.lastMessageSummary = summary;
+            this.session.lastMessageSummaryAt = Date.now();
+            this.session.save();
+            return [
+                this.toSummaryMessage(summary, this.session.lastMessageSummaryAt, ''),
+                ...messages.slice(-appConfig.messageKeep),
+            ];
+        }
+        else {
+            // 4B. 增量摘要更新
+            const newMessages = messages.filter((m) => m.createdAt > this.session.lastMessageSummaryAt);
+            logger.debug('new messages length:', newMessages.length);
+            if (newMessages.length < this.config.summaryThreshold) {
+                // 新消息少于阈值条：返回摘要 + 从摘要时刻起的所有消息
+                const fromSummary = messages.filter((m) => m.createdAt >= this.session.lastMessageSummaryAt);
+                return [
+                    this.toSummaryMessage(this.session.lastMessageSummary, this.session.lastMessageSummaryAt, ''),
+                    ...fromSummary,
+                ];
+            }
+            else {
+                // 新消息超过阈值条，重新生成摘要
+                const summary = await this.generateSummaryAsync(newMessages.slice(0, -appConfig.messageKeep), this.session.lastMessageSummary);
+                this.session.lastMessageSummary = summary;
+                this.session.lastMessageSummaryAt = Date.now();
+                this.session.save();
+                return [
+                    this.toSummaryMessage(summary, this.session.lastMessageSummaryAt, ''),
+                    ...messages.slice(-appConfig.messageKeep),
+                ];
+            }
+        }
+    }
+    /**
+     * 生成摘要提示词
+     */
+    buildSummaryPrompt(messages, lastSummary) {
+        const conversation = messages
+            .filter((m) => m.role === 'user' || m.role === 'assistant')
+            .map((m) => `${m.role === 'user' ? '用户' : '助手'}: ${m.content}${m.toolCalls ? JSON.stringify(m.toolCalls) : ''}`)
+            .join('\n');
+        return `请分析以下对话内容，生成一个简洁的摘要，保留关键信息、错误信息和上下文。
+
+对话内容：
+${conversation}
+
+${lastSummary ? '上一次内容摘要:\n' + lastSummary : ''}
+
+请用以下格式返回摘要（只返回摘要，不要其他内容）：
+【摘要】：简要概括对话主题和关键信息（不超过100字）
+【要点】：列出2-5个关键要点
+【错误】：列出犯过的错误`;
+    }
+    /**
+     * 生成对话摘要
+     */
+    async generateSummaryAsync(messages, lastSummary) {
+        const summaryPrompt = this.buildSummaryPrompt(messages, lastSummary);
+        const llmClient = new LLMClient((await modelsService.list()).data.map((x) => toModel(x)), [{ role: 'user', content: summaryPrompt }], this.signal, []);
+        const response = await llmClient.Chat();
+        const content = (response.content || '').trim();
+        if (!content) {
+            logger.warn('摘要内容为空，保留旧摘要', {
+                lastSummary,
+                responseKeys: Object.keys(response),
+            });
+            return lastSummary || '（摘要生成失败，内容为空）';
+        }
+        return content;
+    }
+}

package/dist/services/model/ModelCapabilities.js

@@ -0,0 +1,141 @@
+/**
+ * 模型能力配置
+ * 定义各模型擅长领域和优先级
+ */
+export const MODEL_CAPABILITIES = {
+    // Anthropic 系列
+    'claude-3-5-sonnet': {
+        strengths: ['reasoning', 'coding', 'analysis', 'writing'],
+        priority: 9,
+        preferLongContext: true,
+    },
+    'claude-3-opus': {
+        strengths: ['reasoning', 'coding', 'analysis', 'writing'],
+        priority: 10,
+        preferLongContext: true,
+    },
+    'claude-3-haiku': {
+        strengths: ['quick', 'simple', 'text'],
+        priority: 5,
+    },
+    // OpenAI 系列
+    'gpt-4o': {
+        strengths: ['reasoning', 'coding', 'vision', 'creative'],
+        priority: 8,
+        preferLongContext: true,
+    },
+    'gpt-4-turbo': {
+        strengths: ['reasoning', 'coding', 'vision'],
+        priority: 8,
+    },
+    'gpt-4': {
+        strengths: ['reasoning', 'coding', 'analysis'],
+        priority: 7,
+    },
+    'gpt-3.5-turbo': {
+        strengths: ['quick', 'simple', 'text'],
+        priority: 4,
+    },
+    // DeepSeek 系列
+    'deepseek-chat': {
+        strengths: ['coding', 'math', 'reasoning', 'text'],
+        priority: 7,
+    },
+    'deepseek-coder': {
+        strengths: ['coding', 'code-review'],
+        priority: 8,
+    },
+    // 字节豆包系列
+    'doubao-pro': {
+        strengths: ['text', 'chinese', 'analysis'],
+        priority: 6,
+    },
+    'doubao-lite': {
+        strengths: ['quick', 'simple', 'chinese'],
+        priority: 4,
+    },
+    // 通义千问
+    'qwen-plus': {
+        strengths: ['text', 'chinese', 'coding'],
+        priority: 6,
+    },
+    'qwen-turbo': {
+        strengths: ['quick', 'simple', 'chinese'],
+        priority: 4,
+    },
+    // Kimi
+    'kimi-plus': {
+        strengths: ['long-context', 'text', 'analysis'],
+        priority: 7,
+        preferLongContext: true,
+    },
+    'kimi-turbo': {
+        strengths: ['text', 'quick'],
+        priority: 5,
+    },
+};
+/**
+ * 内容分析标签定义
+ */
+export const CAPABILITY_KEYWORDS = {
+    // 编程相关
+    coding: [
+        'code', '编程', '代码', '函数', 'algorithm', 'python', 'javascript',
+        'typescript', 'java', 'bug', 'debug', 'api', 'git', 'sql', 'regex',
+        'class', 'interface', 'module', 'import', 'export', 'compile', 'debug'
+    ],
+    // 数学相关
+    math: [
+        'math', '数学', '计算', 'equation', '公式', '求导', '积分', '矩阵',
+        '概率', '统计', 'algorithm', '算法', '数值', 'algebra'
+    ],
+    // 推理分析
+    reasoning: [
+        'reasoning', '分析', '推理', '逻辑', '思考', '为什么', '原因',
+        '分析', 'evaluate', 'compare', 'difference', 'explain'
+    ],
+    // 创意写作
+    creative: [
+        '创意', 'write', 'story', 'poem', '小说', '文章', '写作',
+        'create', '设计', 'imagine', ' brainstorm'
+    ],
+    // 视觉/图像
+    vision: [
+        'image', '图片', '图像', 'vision', '识别', 'ocr', '图表',
+        'vision', 'visual', 'photo'
+    ],
+    // 长上下文
+    'long-context': [
+        '长文', '总结', '摘要', '文档', '合同', '论文', '报告',
+        '全文', '这篇文章', '这本书', '详细'
+    ],
+    // 中文相关
+    chinese: [
+        '中文', ' chinese', '中国', '汉字', '文言文', '古诗'
+    ],
+    // 快速响应
+    quick: [
+        'quick', 'quickly', '简单', '快', ' brief', '简短'
+    ],
+};
+/**
+ * 获取模型的默认配置
+ */
+export function getModelCapabilityConfig(modelId) {
+    // 尝试精确匹配
+    if (MODEL_CAPABILITIES[modelId]) {
+        return MODEL_CAPABILITIES[modelId];
+    }
+    // 尝试前缀匹配
+    const prefix = modelId.split('-').slice(0, 2).join('-');
+    for (const key of Object.keys(MODEL_CAPABILITIES)) {
+        if (key.startsWith(prefix)) {
+            return MODEL_CAPABILITIES[key];
+        }
+    }
+    // 默认配置
+    return {
+        strengths: ['text'],
+        priority: 5,
+    };
+}

package/dist/services/model/index.js

@@ -0,0 +1,4 @@
+/**
+ * 模型选择模块
+ */
+export * from './ModelCapabilities';

package/dist/services/models.js

@@ -0,0 +1,16 @@
+export function toModel(m) {
+    return {
+        id: String(m.id),
+        modelName: m.modelName,
+        modelId: m.modelId,
+        provider: m.provider,
+        type: m.type || 'chat',
+        description: m.description || '',
+        capabilities: m.capabilities || [],
+        maxTokens: m.maxTokens || 0,
+        isActive: m.isActive,
+        baseUrl: m.baseUrl,
+        score: m.score || 0,
+        isPrimary: m.isPrimary
+    };
+}

package/dist/services/session/MigrationManager.js

@@ -0,0 +1,176 @@
+import path from 'path';
+import fs from 'fs';
+import { getLogger } from '@pocketclaw/shared';
+const logger = getLogger('MigrationManager');
+export class MigrationManager {
+    db;
+    migrationsDir;
+    constructor(db, migrationsDir) {
+        this.db = db;
+        this.migrationsDir = migrationsDir;
+        this.initMigrationTable();
+    }
+    /**
+     * 初始化迁移记录表
+     */
+    initMigrationTable() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS schema_migrations (
+        version INTEGER PRIMARY KEY,
+        name TEXT NOT NULL,
+        applied_at INTEGER NOT NULL
+      );
+    `);
+    }
+    /**
+     * 获取当前数据库版本
+     */
+    getCurrentVersion() {
+        const row = this.db.prepare('SELECT MAX(version) as version FROM schema_migrations').get();
+        return row?.version ?? 0;
+    }
+    /**
+     * 获取所有已应用的迁移
+     */
+    getAppliedMigrations() {
+        return this.db.prepare('SELECT * FROM schema_migrations ORDER BY version').all();
+    }
+    /**
+     * 执行数据库迁移
+     */
+    migrate() {
+        const currentVersion = this.getCurrentVersion();
+        const appliedMigrations = this.getAppliedMigrations();
+        const appliedNames = new Set(appliedMigrations.map(m => m.name));
+        // 读取迁移目录下的所有 SQL 文件
+        if (!fs.existsSync(this.migrationsDir)) {
+            logger.info(`Migrations directory does not exist: ${this.migrationsDir}`);
+            return;
+        }
+        const migrationFiles = fs.readdirSync(this.migrationsDir)
+            .filter(file => file.endsWith('.sql'))
+            .sort(); // 按文件名排序
+        let applied = 0;
+        for (const file of migrationFiles) {
+            // 从文件名提取版本号和名称
+            // 格式: XXX_description.sql 例如: 001_create_sessions_table.sql
+            const match = file.match(/^(\d+)_(.+)\.sql$/);
+            if (!match) {
+                logger.warn(`Skipping invalid migration file: ${file}`);
+                continue;
+            }
+            const version = parseInt(match[1], 10);
+            const name = match[2];
+            // 如果已应用，跳过
+            if (appliedNames.has(name)) {
+                logger.debug(`Skipping already applied migration: ${name}`);
+                continue;
+            }
+            // 如果版本低于当前版本，报错（防止降级迁移）
+            if (version <= currentVersion) {
+                logger.error(`Migration ${name} has version ${version} but current version is ${currentVersion}. Cannot apply older migration.`);
+                continue;
+            }
+            // 读取并执行 SQL 文件
+            const filePath = path.join(this.migrationsDir, file);
+            const sql = fs.readFileSync(filePath, 'utf-8');
+            logger.info(`Applying migration: ${name} (version: ${version})`);
+            try {
+                // 分割多条 SQL 语句并执行
+                const statements = this.splitSqlStatements(sql);
+                for (const statement of statements) {
+                    if (statement.trim() && !statement.trim().startsWith('SELECT')) {
+                        try {
+                            this.db.exec(statement);
+                        }
+                        catch (execError) {
+                            // 忽略 "duplicate column name" 错误（列已存在）
+                            if (execError.code !== 'SQLITE_ERROR' || !execError.message?.includes('duplicate column name')) {
+                                throw execError;
+                            }
+                            logger.warn(`Column already exists, skipping: ${statement.substring(0, 50)}...`);
+                        }
+                    }
+                }
+                // 记录迁移
+                this.db.prepare('INSERT INTO schema_migrations (version, name, applied_at) VALUES (?, ?, ?)').run(version, name, Date.now());
+                logger.info(`Successfully applied migration: ${name}`);
+                applied++;
+            }
+            catch (error) {
+                logger.error(`Failed to apply migration ${name}: ${error}`);
+                throw error;
+            }
+        }
+        if (applied === 0) {
+            logger.info('Database is up to date');
+        }
+        else {
+            logger.info(`Applied ${applied} migration(s)`);
+        }
+    }
+    /**
+     * 分割 SQL 语句（支持 ; 分隔）
+     * 忽略 SQL 注释
+     */
+    splitSqlStatements(sql) {
+        const lines = sql.split('\n');
+        const statements = [];
+        let currentStatement = '';
+        let inBlockComment = false;
+        for (const line of lines) {
+            const trimmed = line.trim();
+            // 跳过空行和单行注释
+            if (!trimmed || trimmed.startsWith('--')) {
+                continue;
+            }
+            // 处理块注释
+            if (inBlockComment) {
+                if (trimmed.includes('*/')) {
+                    inBlockComment = false;
+                }
+                continue;
+            }
+            if (trimmed.startsWith('/*')) {
+                inBlockComment = true;
+                continue;
+            }
+            currentStatement += ' ' + trimmed;
+            // 检查是否以分号结尾
+            if (currentStatement.trim().endsWith(';')) {
+                statements.push(currentStatement.trim());
+                currentStatement = '';
+            }
+        }
+        // 处理最后一条语句（可能没有分号）
+        if (currentStatement.trim()) {
+            statements.push(currentStatement.trim());
+        }
+        return statements;
+    }
+    /**
+     * 获取迁移状态
+     */
+    getStatus() {
+        const currentVersion = this.getCurrentVersion();
+        const appliedMigrations = this.getAppliedMigrations();
+        if (!fs.existsSync(this.migrationsDir)) {
+            return { currentVersion, applied: appliedMigrations, pending: [], error: 'Migrations directory not found' };
+        }
+        const migrationFiles = fs.readdirSync(this.migrationsDir)
+            .filter(file => file.endsWith('.sql'))
+            .sort();
+        const pending = [];
+        for (const file of migrationFiles) {
+            const match = file.match(/^(\d+)_(.+)\.sql$/);
+            if (match) {
+                const name = match[2];
+                const applied = appliedMigrations.some(m => m.name === name);
+                if (!applied) {
+                    pending.push(file);
+                }
+            }
+        }
+        return { currentVersion, applied: appliedMigrations, pending };
+    }
+}