agens-studio 0.1.0

package/src/services/mimoVision.js

@@ -0,0 +1,296 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { createHash } from 'node:crypto';
+import { config } from '../../config.js';
+
+/**
+ * mimo 视觉识图服务
+ * ------------------------------------------------------------------
+ * 用 mimo-v2.5（多模态）识别上传图片，按维度输出结构化描述。
+ * 供图生图的"保留原图结构"使用。
+ *
+ * 缓存：按图片文件内容的 hash，同一张图只识一次（存 data/vision_cache.json）。
+ * 失败：直接抛错，由上层提示用户重试（不降级，保证"保留"基于真实识别）。
+ * ------------------------------------------------------------------
+ */
+
+let _cache = null;
+
+async function loadCache() {
+  if (_cache) return _cache;
+  try {
+    _cache = JSON.parse(await fs.readFile(config.visionCache.file, 'utf8'));
+    if (typeof _cache !== 'object' || _cache === null) _cache = {};
+  } catch {
+    _cache = {};
+  }
+  return _cache;
+}
+
+async function saveCache() {
+  if (!_cache) return;
+  await fs.writeFile(config.visionCache.file, JSON.stringify(_cache, null, 2), 'utf8');
+}
+
+/** 启动时调用 */
+export async function init() {
+  await fs.mkdir(config.dirs.data, { recursive: true });
+  await loadCache();
+}
+
+/** 计算图片 buffer 的内容 hash（缓存 key） */
+function hashOf(buf) {
+  return createHash('sha256').update(buf).digest('hex').slice(0, 32);
+}
+
+/**
+ * 把本地路径转成 base64 data uri + buffer
+ * 支持：/uploads/xxx、/assets/images/xxx、/assets/videos/xxx
+ */
+async function readLocalImage(localPath) {
+  let absPath;
+  let isVideo = false;
+  if (localPath.startsWith('/uploads/')) {
+    absPath = path.join(config.dirs.uploads, path.basename(localPath));
+  } else if (localPath.startsWith('/assets/images/')) {
+    absPath = path.join(config.dirs.images, path.basename(localPath));
+  } else if (localPath.startsWith('/assets/videos/')) {
+    absPath = path.join(config.dirs.videos, path.basename(localPath));
+    isVideo = true;
+  } else {
+    throw new Error('只支持本地上传的图片或视频');
+  }
+  const buf = await fs.readFile(absPath);
+  const ext = path.extname(absPath).slice(1).toLowerCase();
+  if (isVideo) {
+    const mime = `video/${ext || 'mp4'}`;
+    return { buf, dataUri: `data:${mime};base64,${buf.toString('base64')}` };
+  }
+  const mime = `image/${ext === 'jpg' ? 'jpeg' : ext || 'png'}`;
+  return { buf, dataUri: `data:${mime};base64,${buf.toString('base64')}` };
+}
+
+/**
+ * 识图：返回结构化描述 { subject, scene, composition, color, style, keepable }
+ * @param {string} imageUrl 本地图片路径（/uploads/xxx 或 /assets/images/xxx）
+ * @returns {Promise<{description:object, cached:boolean}>}
+ */
+export async function describeImage(imageUrl) {
+  const { buf, dataUri } = await readLocalImage(imageUrl);
+  const key = hashOf(buf);
+
+  // 命中缓存
+  const cache = await loadCache();
+  if (cache[key]) {
+    return { description: cache[key], cached: true };
+  }
+
+  // 调 mimo-v2.5 多模态
+  const description = await callVision(dataUri);
+  cache[key] = description;
+  await saveCache();
+  return { description, cached: false };
+}
+
+/**
+ * 调用 mimo-v2.5 识图，要求按维度输出
+ */
+async function callVision(dataUri) {
+  const cfg = config.mimo;
+  const system = [
+    '你是图像分析专家。请分析图片，严格按以下 6 个维度输出，每个维度一行，格式为「维度名：内容」。',
+    '',
+    '维度：',
+    '主体：画面核心对象是谁/是什么，什么状态/动作',
+    '场景：发生在哪里，背景环境',
+    '构图：画面布局（居中/三分法/对称/广角等），主体位置',
+    '色调：主色调、光线氛围',
+    '风格：写实/动漫/3D/艺术/摄影等',
+    '可保留元素：图生图时应该保持不变的元素（主体位置、构图、关键物件）',
+    '',
+    '要求：',
+    '1. 必须输出全部 6 行，缺一不可',
+    '2. 每行内容简洁（5-30字），不要解释',
+    '3. 不要输出其它任何内容',
+  ].join('\n');
+
+  const res = await fetch(`${cfg.baseUrl}${cfg.endpoint}`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'api-key': cfg.apiKey,
+    },
+    body: JSON.stringify({
+      model: cfg.visionModel,
+      messages: [
+        { role: 'system', content: system },
+        {
+          role: 'user',
+          content: [
+            { type: 'text', text: '请分析这张图片' },
+            { type: 'image_url', image_url: { url: dataUri } },
+          ],
+        },
+      ],
+      max_completion_tokens: 800,
+      temperature: 0.3, // 识图要稳定，温度调低
+      top_p: 0.9,
+      stream: false,
+    }),
+  });
+
+  const text = await res.text();
+  if (!res.ok) {
+    throw new Error(`识图失败 (${res.status}): ${text.slice(0, 200)}`);
+  }
+  let data;
+  try { data = JSON.parse(text); } catch { throw new Error('识图响应不是有效 JSON'); }
+  const content = data.choices?.[0]?.message?.content;
+  if (!content) throw new Error('识图响应未包含内容');
+
+  return parseDescription(content);
+}
+
+/**
+ * 把模型的维度描述文本解析成对象
+ * 输入形如：
+ *   主体：女研究员手持烧瓶
+ *   场景：实验室
+ *   ...
+ */
+function parseDescription(content) {
+  const obj = {
+    subject: '', scene: '', composition: '', color: '', style: '', keepable: '',
+  };
+  const map = {
+    主体: 'subject', 场景: 'scene', 构图: 'composition',
+    色调: 'color', 风格: 'style', 可保留元素: 'keepable',
+  };
+  for (const line of content.split(/\n/)) {
+    const m = line.match(/^\s*([^：:]+)[：:]\s*(.+)$/);
+    if (!m) continue;
+    const key = map[m[1].trim()];
+    if (key) obj[key] = m[2].trim();
+  }
+  return obj;
+}
+
+/** 把描述对象转成给 pro 模型看的纯文本上下文 */
+export function descriptionToText(d) {
+  if (!d) return '';
+  return [
+    d.subject && `主体：${d.subject}`,
+    d.scene && `场景：${d.scene}`,
+    d.composition && `构图：${d.composition}`,
+    d.color && `色调：${d.color}`,
+    d.style && `风格：${d.style}`,
+    d.keepable && `可保留元素：${d.keepable}`,
+  ].filter(Boolean).join('；');
+}
+
+/**
+ * 复看：看 agnes 生成的图/视频，评价 + 给出改进提示词
+ * @param {string} assetPath 生成物的本地路径（/assets/images/xxx.png 或 /assets/videos/xxx.mp4）
+ * @param {string} prompt 生成时用的提示词
+ * @param {string} mode 生成模式
+ * @returns {Promise<{rating, comment, problems, suggestion, improvedPrompt}>}
+ */
+export async function reviewImage(assetPath, prompt, mode) {
+  const isVideo = assetPath.includes('/assets/videos/') || assetPath.endsWith('.mp4');
+  const { dataUri } = await readLocalImage(assetPath);
+  const cfg = config.mimo;
+
+  const mediaLabel = isVideo ? '视频' : '图片';
+  const system = [
+    `你是 AI ${mediaLabel}质量评审专家。请查看用户用 AI 生成的${mediaLabel}，对照原始提示词，给出评价和改进建议。`,
+    '',
+    isVideo ? '【视频评审重点】画面动态感、运动流畅度、主体一致性、镜头运动合理性、画面质量' : '',
+    '【必须按以下格式输出，每项一行】',
+    `评价：这条${mediaLabel}的优点（2-3点）`,
+    `问题：这条${mediaLabel}的不足之处（2-3点，要具体）`,
+    '建议：针对问题，提示词应该怎么改（一句话）',
+    '改进提示词：基于原提示词修改后的完整提示词（直接可用，不要解释）',
+    '',
+    '要求：',
+    '1. 必须输出全部 4 行',
+    '2. 评价和问题要基于实际看到的画面，不要泛泛而谈',
+    '3. 改进提示词必须是完整的、可直接用于重新生成的提示词',
+    '4. 改进提示词不要带任何前缀说明，直接输出提示词内容',
+  ].filter(Boolean).join('\n');
+
+  const userText = `原始提示词：${prompt}\n生成模式：${mode}\n请评价这条生成结果并给出改进提示词。`;
+
+  const res = await fetch(`${cfg.baseUrl}${cfg.endpoint}`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'api-key': cfg.apiKey,
+    },
+    body: JSON.stringify({
+      model: cfg.visionModel,
+      messages: [
+        { role: 'system', content: system },
+        {
+          role: 'user',
+          content: [
+            { type: 'text', text: userText },
+            isVideo
+              ? { type: 'video_url', video_url: { url: dataUri }, fps: 2, media_resolution: 'default' }
+              : { type: 'image_url', image_url: { url: dataUri } },
+          ],
+        },
+      ],
+      max_completion_tokens: 4096,
+      temperature: 0.4,
+      top_p: 0.9,
+      stream: false,
+    }),
+  });
+
+  const text = await res.text();
+  if (!res.ok) {
+    throw new Error(`复看失败 (${res.status}): ${text.slice(0, 200)}`);
+  }
+  let data;
+  try { data = JSON.parse(text); } catch { throw new Error('复看响应不是有效 JSON'); }
+  const content = data.choices?.[0]?.message?.content;
+  if (!content) throw new Error('复看响应未包含内容');
+
+  return parseReview(content);
+}
+
+/** 解析复看结果 */
+function parseReview(content) {
+  const result = { rating: '', comment: '', suggestion: '', improvedPrompt: '' };
+  const lines = content.split(/\n/);
+  let currentKey = null;
+  let buffer = [];
+  const keyMap = { 评价: 'comment', 问题: 'problems', 建议: 'suggestion', '改进提示词': 'improvedPrompt' };
+
+  for (const line of lines) {
+    const m = line.match(/^\s*(评价|问题|建议|改进提示词)[：:]\s*(.*)$/);
+    if (m) {
+      // 保存上一个 key 的内容
+      if (currentKey && buffer.length) {
+        if (keyMap[currentKey] === 'comment') result.comment = buffer.join('；');
+        else if (currentKey === '问题') result.problems = buffer.join('；');
+        else if (keyMap[currentKey]) result[keyMap[currentKey]] = buffer.join('\n');
+      }
+      currentKey = m[1].trim();
+      buffer = [m[2]].filter(Boolean);
+    } else if (currentKey) {
+      buffer.push(line.trim());
+    }
+  }
+  // 保存最后一个
+  if (currentKey && buffer.length) {
+    if (currentKey === '评价') result.comment = buffer.join('；');
+    else if (currentKey === '问题') result.problems = buffer.join('；');
+    else if (currentKey === '建议') result.suggestion = buffer.join('\n');
+    else if (currentKey === '改进提示词') result.improvedPrompt = buffer.join('\n').trim();
+  }
+
+  // rating：有问题则 needs_improve，否则 good
+  result.rating = result.problems && result.problems.length > 5 ? 'needs_improve' : 'good';
+  return result;
+}

package/src/services/promptMemory.js

@@ -0,0 +1,276 @@
+import fs from 'node:fs/promises';
+import { config } from '../../config.js';
+
+/**
+ * 提示词记忆库
+ * ------------------------------------------------------------------
+ * 存储「原始输入 → 优化结果 → 用户反馈」的样本，让 mimo 越用越懂用户。
+ *
+ * 数据结构：data/prompt_memory.json
+ * {
+ *   samples: [{
+ *     id, kind('positive'|'negative'), original, optimized, mode,
+ *     rating(-1/0/1), tags[], adoptedCount, createdAt
+ *   }],
+ *   globalPrefs: {
+ *     positive: { favoriteStyle, commonKeywords[] },   // 正向偏好
+ *     negative: { favoriteStyle, commonKeywords[] }    // 反向偏好（用户常排除的元素）
+ *   }
+ * }
+ *
+ * ⚠️ 正向 / 反向样本完全独立存储与检索，避免互相污染。
+ *
+ * 评分机制：
+ *   rating = 1  用户点赞（👍）
+ *   rating = 0  未反馈（默认）
+ *   rating = -1 用户点踩（👎）
+ *   adoptedCount 每次优化结果被「采用」+1
+ * ------------------------------------------------------------------
+ */
+
+let _cache = null;
+
+async function load() {
+  if (_cache) return _cache;
+  try {
+    const raw = await fs.readFile(config.promptMemory.file, 'utf8');
+    _cache = JSON.parse(raw);
+    if (!Array.isArray(_cache.samples)) _cache.samples = [];
+    // 兼容旧数据：老样本没有 kind 字段，归为 positive
+    _cache.samples.forEach((s) => { if (!s.kind) s.kind = 'positive'; });
+    // globalPrefs 升级为区分 positive/negative
+    if (!_cache.globalPrefs) _cache.globalPrefs = {};
+    if (!_cache.globalPrefs.positive) _cache.globalPrefs.positive = { favoriteStyle: '', commonKeywords: [] };
+    if (!_cache.globalPrefs.negative) _cache.globalPrefs.negative = { favoriteStyle: '', commonKeywords: [] };
+    // 兼容旧版扁平结构
+    if (_cache.globalPrefs.favoriteStyle && !_cache.globalPrefs.positive.favoriteStyle) {
+      _cache.globalPrefs.positive = { favoriteStyle: _cache.globalPrefs.favoriteStyle, commonKeywords: _cache.globalPrefs.commonKeywords || [] };
+      delete _cache.globalPrefs.favoriteStyle;
+      delete _cache.globalPrefs.commonKeywords;
+    }
+  } catch {
+    _cache = {
+      samples: [],
+      globalPrefs: {
+        positive: { favoriteStyle: '', commonKeywords: [] },
+        negative: { favoriteStyle: '', commonKeywords: [] },
+      },
+    };
+  }
+  return _cache;
+}
+
+async function save() {
+  if (!_cache) return;
+  await fs.writeFile(config.promptMemory.file, JSON.stringify(_cache, null, 2), 'utf8');
+}
+
+/** 启动时调用：确保目录就绪 */
+export async function init() {
+  await fs.mkdir(config.dirs.data, { recursive: true });
+  await load();
+}
+
+/**
+ * 从一段中文文本提取关键词标签（简单分词，用于匹配相关性）
+ * 取 2-6 字的中文片段 + 英文单词
+ */
+function extractTags(text) {
+  if (!text) return [];
+  const tags = new Set();
+  // 英文单词
+  const en = text.match(/[a-zA-Z]{3,}/g) || [];
+  en.forEach((w) => tags.add(w.toLowerCase()));
+  // 中文 2-4 字词（简单滑动窗口，够用）
+  const cn = text.match(/[\u4e00-\u9fa5]{2,4}/g) || [];
+  cn.forEach((w) => tags.add(w));
+  return Array.from(tags).slice(0, 12);
+}
+
+/**
+ * 新增一个样本（优化时调用）
+ * @param {object} input
+ * @param {'positive'|'negative'} input.kind 正向 / 反向
+ * @returns 新建的样本对象（含 id）
+ */
+export async function addSample({ kind = 'positive', original, optimized, mode, imageDescription }) {
+  const db = await load();
+  const sample = {
+    id: `s_${Date.now()}_${Math.random().toString(36).slice(2, 7)}`,
+    kind,
+    original: original || '',
+    optimized: optimized || '',
+    mode: mode || '',
+    rating: 0,
+    tags: extractTags(original + ' ' + optimized),
+    adoptedCount: 0,
+    correction: '',        // 点踩原因（用户写的不满）
+    rewrites: [],          // 重写历史 [{ instruction, result, accepted }]
+    imageDescription: imageDescription || '',  // 图生图时的识图结果（仅 img2img 有）
+    createdAt: Date.now(),
+  };
+  db.samples.unshift(sample);
+  prune(db);
+  await save();
+  return sample;
+}
+
+/**
+ * 更新样本：评分 / 采纳计数 / 点踩原因 / 重写记录
+ * @param {string} id
+ * @param {object} patch { rating?, adoptedDelta?, correction?, rewrite? }
+ *   - rewrite: { instruction, result } 会追加到 rewrites 并把 optimized 更新为最新结果
+ */
+export async function updateSample(id, patch = {}) {
+  const db = await load();
+  const s = db.samples.find((x) => x.id === id);
+  if (!s) return null;
+  if (typeof patch.rating === 'number') s.rating = patch.rating;
+  if (typeof patch.adoptedDelta === 'number') s.adoptedCount += patch.adoptedDelta;
+  if (typeof patch.correction === 'string' && patch.correction.trim()) {
+    s.correction = patch.correction.trim();
+  }
+  if (patch.rewrite) {
+    s.rewrites.push({
+      instruction: patch.rewrite.instruction || '',
+      result: patch.rewrite.result || '',
+      accepted: !!patch.rewrite.accepted,
+    });
+    // 重写后，最新结果作为样本的 optimized（便于检索匹配）
+    if (patch.rewrite.result) {
+      s.optimized = patch.rewrite.result;
+      // 重新提取 tags，覆盖更多关键词
+      s.tags = extractTags(s.original + ' ' + s.optimized);
+    }
+  }
+  await save();
+  // 评分变化后，尝试更新对应 kind 的全局偏好
+  maybeRefreshPrefs(db, s.kind);
+  return s;
+}
+
+/**
+ * 检索与当前输入最相关的 N 条高分样本（喂给 mimo）
+ * 只在同一 kind 内检索（正向不混反向）
+ */
+export async function getRelevantSamples(input, mode, limit, kind = 'positive') {
+  const db = await load();
+  const inputTags = new Set(extractTags(input));
+  const n = limit || config.promptMemory.feedSamples;
+
+  // 候选：同 kind、有评分或被采纳过的样本
+  const candidates = db.samples.filter(
+    (s) => s.kind === kind && s.rating >= 0 && (s.rating > 0 || s.adoptedCount > 0)
+  );
+
+  const scored = candidates.map((s) => {
+    const overlap = s.tags.filter((t) => inputTags.has(t)).length;
+    const score = overlap * 5 + s.rating * 3 + Math.min(s.adoptedCount, 5);
+    return { s, score };
+  });
+  scored.sort((a, b) => b.score - a.score);
+
+  // 同类模式优先（mode 匹配加分已在 score 之外，这里做稳定排序的二级条件）
+  scored.sort((a, b) => {
+    if (a.s.mode === mode && b.s.mode !== mode) return -1;
+    if (b.s.mode === mode && a.s.mode !== mode) return 1;
+    return b.score - a.score;
+  });
+
+  return scored.slice(0, n).map((x) => x.s);
+}
+
+/**
+ * 检索相关的「点踩原因 + 重写指令」（反面教材 / 修正要求）
+ * 用于告诉 mimo「这类主题用户曾要求避免/修改什么」
+ * 返回 [{ original, correction, rewrites:[{instruction}] }]
+ */
+export async function getCorrections(input, mode, limit = 3, kind = 'positive') {
+  const db = await load();
+  const inputTags = new Set(extractTags(input));
+  const candidates = db.samples.filter(
+    (s) =>
+      s.kind === kind &&
+      ((s.correction && s.correction.trim()) || (s.rewrites && s.rewrites.length))
+  );
+  const scored = candidates.map((s) => {
+    const overlap = s.tags.filter((t) => inputTags.has(t)).length;
+    return { s, score: overlap * 5 };
+  });
+  scored.sort((a, b) => b.score - a.score);
+  scored.sort((a, b) => {
+    if (a.s.mode === mode && b.s.mode !== mode) return -1;
+    if (b.s.mode === mode && a.s.mode !== mode) return 1;
+    return b.score - a.score;
+  });
+  return scored.slice(0, limit).map((x) => ({
+    original: x.s.original,
+    correction: x.s.correction || '',
+    rewrites: (x.s.rewrites || []).map((r) => r.instruction),
+  }));
+}
+
+/** 取全局偏好（按 kind 分别返回） */
+export async function getGlobalPrefs(kind = 'positive') {
+  const db = await load();
+  return db.globalPrefs[kind] || { favoriteStyle: '', commonKeywords: [] };
+}
+
+/**
+ * 当高分样本足够多时，提炼对应 kind 的全局偏好
+ */
+function maybeRefreshPrefs(db, kind) {
+  const good = db.samples.filter((s) => s.kind === kind && s.rating >= 1);
+  if (good.length < config.promptMemory.minSamplesForPrefs) return;
+
+  // 统计 optimized 里高频标签
+  const freq = new Map();
+  for (const s of good) {
+    for (const t of s.tags) freq.set(t, (freq.get(t) || 0) + 1);
+  }
+  const top = Array.from(freq.entries())
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, 8)
+    .map(([k]) => k);
+
+  db.globalPrefs[kind] = {
+    commonKeywords: top,
+    favoriteStyle: top.slice(0, 3).join('、'),
+  };
+}
+
+/**
+ * 容量淘汰：超过 maxSamples 时，按 (rating*3 + adoptedCount) 升序删除低价值样本
+ */
+function prune(db) {
+  const max = config.promptMemory.maxSamples;
+  if (db.samples.length <= max) return;
+  db.samples.sort((a, b) => b.rating * 3 + b.adoptedCount - (a.rating * 3 + a.adoptedCount));
+  db.samples = db.samples.slice(0, max);
+}
+
+/** 按 id 取单个样本（重写时用） */
+export async function getSample(id) {
+  const db = await load();
+  return db.samples.find((s) => s.id === id) || null;
+}
+
+/** 调试/管理用：返回统计信息（按 kind 分别统计） */
+export async function stats() {
+  const db = await load();
+  const pick = (k) => db.samples.filter((s) => s.kind === k);
+  return {
+    total: db.samples.length,
+    positive: {
+      total: pick('positive').length,
+      liked: pick('positive').filter((s) => s.rating >= 1).length,
+      adopted: pick('positive').filter((s) => s.adoptedCount > 0).length,
+    },
+    negative: {
+      total: pick('negative').length,
+      liked: pick('negative').filter((s) => s.rating >= 1).length,
+      adopted: pick('negative').filter((s) => s.adoptedCount > 0).length,
+    },
+    prefs: db.globalPrefs,
+  };
+}