aixxai 1.0.0 → 1.2.0

package/src/commands/recharge.js

@@ -0,0 +1,143 @@
+/**
+ * AIXX CLI - recharge 命令
+ *
+ * 显示充值方式。优先尝试调后端 creem/pay 接口生成在线充值链接；
+ * 如果后端不支持或失败，则给出通用引导（联系客服/后台充值）。
+ */
+
+import { existsSync, readFileSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+import { DEFAULT_BASE_URL } from '../../bin/aixx.js';
+
+// 所有对外请求统一 15 秒超时
+const FETCH_TIMEOUT = 15000;
+
+/**
+ * 从环境变量或本地账号文件读取 apiKey。
+ */
+function loadApiKey() {
+  if (process.env.AIXX_API_KEY) return process.env.AIXX_API_KEY;
+  const accountFile = join(homedir(), '.aixx', 'account.json');
+  if (existsSync(accountFile)) {
+    try {
+      const acc = JSON.parse(readFileSync(accountFile, 'utf-8'));
+      if (acc.apiKey) return acc.apiKey;
+    } catch (e) {}
+  }
+  return null;
+}
+
+/**
+ * 尝试调后端的 creem 支付接口生成充值链接。
+ * New-API 的在线充值常见接口：
+ *   POST /api/user/creem/pay   { amount, ... }
+ * 不同版本字段不一，失败就回退到手动引导。
+ */
+async function tryGetCreemLink(apiKey, baseUrl, amount) {
+  const apiBase = baseUrl.replace(/\/v1$/, '');
+  const candidates = [
+    {
+      url: `${apiBase}/api/user/creem/pay`,
+      body: { amount, currency: 'USD', gateway: 'creem' },
+    },
+    {
+      url: `${apiBase}/api/user/topup`,
+      body: { amount, top_up_code: '', payment_method: 'creem' },
+    },
+  ];
+
+  for (const c of candidates) {
+    try {
+      const resp = await fetch(c.url, {
+        method: 'POST',
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(c.body),
+        signal: AbortSignal.timeout(FETCH_TIMEOUT),
+      });
+      if (!resp.ok) continue;
+      const data = await resp.json().catch(() => null);
+      if (!data) continue;
+      // 多种可能的字段名兜底
+      const link =
+        data.data?.url ||
+        data.data?.payment_url ||
+        data.data?.checkout_url ||
+        data.url ||
+        data.payment_url;
+      if (link) return link;
+    } catch (e) {
+      // 超时单独提示一次（其余错误静默试下一个候选接口）
+      if (e?.name === 'TimeoutError' || e?.name === 'AbortError') {
+        console.log('   ⚠️  连接超时，请检查网络');
+      }
+    }
+  }
+  return null;
+}
+
+export async function recharge(subArgs) {
+  console.log('╔══════════════════════════════════════════╗');
+  console.log('║      AIXX 充值                             ║');
+  console.log('╚══════════════════════════════════════════╝\n');
+
+  const apiKey = loadApiKey();
+  const baseUrl = process.env.AIXX_BASE_URL || DEFAULT_BASE_URL;
+
+  // 从参数取金额，默认 $5（最低）
+  let amount = 5;
+  if (subArgs[0]) {
+    const n = Number(subArgs[0]);
+    if (!Number.isNaN(n) && n > 0) amount = n;
+  }
+
+  if (!apiKey) {
+    console.log('⚠️  未检测到AIXX API Key，以下为通用充值方式：\n');
+    console.log('充值方式：');
+    console.log('   信用卡 / ApplePay：登录 AIXX 后台 → 充值 → Creem');
+    console.log('   USDT 加密货币：联系客服或后台提交');
+    console.log(`\n   最低充值 $5`);
+    console.log(`\n🌐 后台地址：${baseUrl.replace(/\/v1$/, '')}`);
+    return;
+  }
+
+  console.log(`使用Key: ${apiKey.slice(0, 12)}...${apiKey.slice(-4)}`);
+  console.log(`充值金额：$${amount}\n`);
+
+  // 尝试生成在线支付链接
+  console.log('🔄 正在生成在线充值链接...');
+  const link = await tryGetCreemLink(apiKey, baseUrl, amount);
+
+  console.log('\n────────────────────────────────────');
+  console.log('💳 充值方式：');
+  console.log('────────────────────────────────────');
+
+  if (link) {
+    console.log('\n  ① 信用卡 / ApplePay（推荐，即时到账）：');
+    console.log(`     ${link}`);
+    console.log('\n     复制链接到浏览器打开即可支付。');
+  } else {
+    console.log('\n  ① 信用卡 / ApplePay：');
+    console.log('     自动生成链接失败，请直接登录后台充值：');
+    console.log(`     ${baseUrl.replace(/\/v1$/, '')}  → 充值`);
+  }
+
+  console.log('\n  ② USDT 加密货币：');
+  console.log('     联系 AIXX 客服，或后台提交 USDT 充值订单');
+  console.log('     （后续会支持自动生成钱包地址）');
+
+  console.log('\n  ③ 微信/支付宝：');
+  console.log('     联系 AIXX 客服走人工充值');
+
+  console.log('\n────────────────────────────────────');
+  console.log(`最低充值 $5（约 ¥${(amount * 7).toFixed(0)}）`);
+  console.log(`充值后额度即时到账，可直接使用。\n`);
+
+  console.log('💡 充值提示：');
+  console.log('   - 充 $5 用 deepseek-chat 能聊 5 万次以上');
+  console.log('   - 充 $20 够用 Claude/GPT 跑一个月');
+  console.log('   - 推荐码注册的用户充值后推荐人有分润\n');
+}

package/src/utils/agentconfig.js

@@ -0,0 +1,374 @@
+/**
+ * agent配置写入工具
+ *
+ * 负责把AIXX的供应商配置写进本地agent的配置文件，实现"零配置"。
+ * 当前支持两个agent：
+ *   1. ZCode      -> ~/.zcode/v2/config.json  （加两个供应商：AIXX-Claude / AIXX-OpenAI）
+ *   2. Claude Code-> ~/.claude/settings.json （往env块写 ANTHROPIC_BASE_URL / ANTHROPIC_AUTH_TOKEN）
+ *
+ * ⛔ 绝对禁止改写 ZCode 的 setting.json（~/.zcode/v2/setting.json）！
+ *   历史教训（2026-08-09 重大事故，见 token-hub/项目体系/TIMELINE.md 会话7）：
+ *   早期版本曾把 setting.json 的 providerFamilyDomain 改成 "aixx"，而 ZCode
+ *   只接受内置家族名（zai/bigmodel），非法值直接导致 ZCode 崩溃、任务/项目丢失。
+ *   本工具从此只允许操作 ZCode 的 config.json（加供应商），绝不碰 setting.json。
+ *
+ * 三条铁律（K哥交代的安全要求）：
+ *   1. 写入前必须备份原文件到 ~/.aixx/backups/
+ *   2. 只做 JSON 读-改-写，绝不整体覆盖
+ *   3. 所有写入都加 "_aixx_managed": true 标记，重复 install 只更新 key 不重建（幂等）
+ *
+ * 纯Node标准库，零依赖。
+ */
+
+import {
+  existsSync,
+  readFileSync,
+  writeFileSync,
+  mkdirSync,
+  copyFileSync,
+} from 'fs';
+import { homedir } from 'os';
+import { join, dirname } from 'path';
+import { randomUUID } from 'crypto';
+
+// AIXX后端地址（去掉/v1，因为ZCode的baseURL要写到主机根，OpenAI的写到/v1）
+// ⚠️ 安全警告：当前用HTTP明文传输API Key（http://）。
+const AIXX_HOST = 'http://14.103.27.195:8080';
+
+// 用 _aixx_managed 标记找供应商时，按"作用域"区分，避免Claude/OpenAI两条记混
+const MANAGED_FLAG = '_aixx_managed';
+
+/**
+ * 生成时间戳字符串，用于备份文件名
+ * 形如 20260808-153045
+ */
+function timestamp() {
+  const d = new Date();
+  const pad = (n) => String(n).padStart(2, '0');
+  return (
+    d.getFullYear() +
+    pad(d.getMonth() + 1) +
+    pad(d.getDate()) +
+    '-' +
+    pad(d.getHours()) +
+    pad(d.getMinutes()) +
+    pad(d.getSeconds())
+  );
+}
+
+/**
+ * 备份一个文件到 ~/.aixx/backups/<原名>-<时间戳>.json
+ * 如果源文件不存在，直接返回null（没东西可备份，属正常）。
+ * 如果同一秒内多次备份（时间戳相同），自动加序号后缀避免覆盖。
+ * 返回值：
+ *   - string：备份文件路径（成功）
+ *   - null：源文件不存在（无需备份，可继续写入）
+ *   - false：源文件存在但备份失败（铁律1：必须中止写入）
+ */
+function backupFile(srcPath) {
+  if (!existsSync(srcPath)) return null;
+  const backupDir = join(homedir(), '.aixx', 'backups');
+  if (!existsSync(backupDir)) mkdirSync(backupDir, { recursive: true });
+  const base = srcPath
+    .split(/[\\/]/)
+    .pop()
+    .replace(/\.json$/, '');
+  // 时间戳精确到秒；若已存在同名备份，加序号 -1, -2 ... 避免覆盖
+  let dest = join(backupDir, `${base}-${timestamp()}.json`);
+  let seq = 1;
+  while (existsSync(dest)) {
+    dest = join(backupDir, `${base}-${timestamp()}-${seq}.json`);
+    seq++;
+  }
+  try {
+    copyFileSync(srcPath, dest);
+    return dest;
+  } catch (e) {
+    // 铁律1：备份失败绝不继续写入。返回false让调用方中止。
+    console.log(`   ⚠️  备份失败: ${e.message}`);
+    return false;
+  }
+}
+
+/**
+ * 安全读取并解析JSON文件。
+ * 失败返回 null（绝不抛出，调用方自行处理）。
+ */
+function readJsonSafe(filePath) {
+  try {
+    const raw = readFileSync(filePath, 'utf-8');
+    return JSON.parse(raw);
+  } catch (e) {
+    return null;
+  }
+}
+
+/**
+ * 在 ZCode config.json 的 provider 里，找出带 _aixx_managed 且 scope 匹配的供应商key。
+ * 返回供应商在config里的key（如 "aixx-claude-xxxx-uuid"），找不到返回null。
+ */
+function findManagedProvider(config, scope) {
+  const providers = config?.provider;
+  if (!providers || typeof providers !== 'object') return null;
+  for (const [key, val] of Object.entries(providers)) {
+    if (val && val[MANAGED_FLAG] === scope) {
+      return key;
+    }
+  }
+  return null;
+}
+
+/**
+ * AIXX-Claude 供应商的模型清单（Anthropic协议，调Claude系）
+ * limit.context / limit.output 是 ZCode 必填字段，单位 token
+ */
+function buildClaudeModels() {
+  return {
+    'claude-sonnet-4-20250514': { limit: { context: 200000, output: 8192 } },
+    'claude-haiku-4-5-20251001': { limit: { context: 200000, output: 8192 } },
+    'claude-opus-4-8': { limit: { context: 200000, output: 8192 } },
+  };
+}
+
+/**
+ * AIXX-OpenAI 供应商的模型清单（OpenAI协议，调国产/DeepSeek/GLM/Kimi）
+ */
+function buildOpenaiModels() {
+  return {
+    'deepseek-chat': { limit: { context: 64000, output: 8192 } },
+    'deepseek-reasoner': { limit: { context: 64000, output: 8192 } },
+    'glm-4-flash': { limit: { context: 128000, output: 4096 } },
+    'glm-4-plus': { limit: { context: 128000, output: 4096 } },
+    'moonshot-v1-8k': { limit: { context: 8000, output: 4096 } },
+  };
+}
+
+/**
+ * 构造一个 AIXX-Claude 供应商对象（Anthropic协议）
+ */
+function buildClaudeProvider(apiKey) {
+  return {
+    name: 'AIXX(Claude)',
+    kind: 'anthropic',
+    options: {
+      apiKey,
+      baseURL: AIXX_HOST,
+      apiKeyRequired: true,
+    },
+    enabled: true,
+    source: 'custom',
+    [MANAGED_FLAG]: 'claude', // 幂等标记 + 作用域
+    models: buildClaudeModels(),
+  };
+}
+
+/**
+ * 构造一个 AIXX-OpenAI 供应商对象（OpenAI协议）
+ */
+function buildOpenaiProvider(apiKey) {
+  return {
+    name: 'AIXX(国产/DeepSeek)',
+    kind: 'openai',
+    options: {
+      apiKey,
+      baseURL: AIXX_HOST + '/v1',
+      apiKeyRequired: true,
+    },
+    enabled: true,
+    source: 'custom',
+    [MANAGED_FLAG]: 'openai', // 幂等标记 + 作用域
+    models: buildOpenaiModels(),
+  };
+}
+
+/**
+ * 写入 ZCode 配置。
+ *
+ * 行为：
+ *   - 如果 ~/.zcode/v2/config.json 不存在 → 直接返回false（没装ZCode）
+ *   - 备份原文件
+ *   - 读-改-写：往 provider 里塞两个AIXX供应商
+ *   - 幂等：如果已有 _aixx_managed 供应商，只更新 apiKey（保留用户可能改过的name/enabled）
+ *   - 任何一步失败都不崩溃，返回false
+ *
+ * 返回 { configured: true/false, note: '...' }
+ */
+export function configureZCode(apiKey) {
+  const zcodeConfigPath = join(homedir(), '.zcode', 'v2', 'config.json');
+
+  if (!existsSync(zcodeConfigPath)) {
+    return { configured: false, note: '未检测到ZCode（~/.zcode/v2/config.json不存在），跳过' };
+  }
+
+  // 读取并解析
+  const config = readJsonSafe(zcodeConfigPath);
+  if (!config || typeof config !== 'object') {
+    console.log('   ⚠️  ZCode config.json 解析失败，跳过ZCode配置（避免破坏文件）');
+    return { configured: false, note: 'ZCode config.json 解析失败' };
+  }
+
+  // 确保 provider 对象存在
+  if (!config.provider || typeof config.provider !== 'object') {
+    config.provider = {};
+  }
+
+  // 备份原文件
+  const backup = backupFile(zcodeConfigPath);
+  if (backup === false) {
+    // 铁律1：备份失败，绝不写入（避免破坏用户现有配置）
+    console.log('   ⚠️  配置备份失败，请手动备份后再试（已跳过ZCode配置）');
+    return { configured: false, note: '配置备份失败，请手动备份后再试' };
+  }
+  if (backup) {
+    console.log(`   📦 已备份ZCode配置: ${backup}`);
+  }
+
+  let updated = 0;
+
+  // --- AIXX-Claude 供应商 ---
+  const claudeKey = findManagedProvider(config, 'claude');
+  if (claudeKey) {
+    // 幂等：只更新key（如果用户改过name/enabled，保留）
+    const existing = config.provider[claudeKey];
+    existing.options = existing.options || {};
+    existing.options.apiKey = apiKey;
+    existing.options.baseURL = AIXX_HOST;
+    existing.options.apiKeyRequired = true;
+    // 模型清单刷成最新（用户不太会改，但万一后端加了新模型能跟上）
+    existing.models = buildClaudeModels();
+    existing.kind = 'anthropic';
+    existing[MANAGED_FLAG] = 'claude';
+    console.log('   ✏️  更新已有AIXX(Claude)供应商（key已刷新）');
+    updated++;
+  } else {
+    // 新增：用一个稳定的UUID做key
+    const newKey = `aixx-claude-${randomUUID()}`;
+    config.provider[newKey] = buildClaudeProvider(apiKey);
+    console.log('   ➕ 新增AIXX(Claude)供应商');
+    updated++;
+  }
+
+  // --- AIXX-OpenAI 供应商 ---
+  const openaiKey = findManagedProvider(config, 'openai');
+  if (openaiKey) {
+    const existing = config.provider[openaiKey];
+    existing.options = existing.options || {};
+    existing.options.apiKey = apiKey;
+    existing.options.baseURL = AIXX_HOST + '/v1';
+    existing.options.apiKeyRequired = true;
+    existing.models = buildOpenaiModels();
+    existing.kind = 'openai';
+    existing[MANAGED_FLAG] = 'openai';
+    console.log('   ✏️  更新已有AIXX(国产/DeepSeek)供应商（key已刷新）');
+    updated++;
+  } else {
+    const newKey = `aixx-openai-${randomUUID()}`;
+    config.provider[newKey] = buildOpenaiProvider(apiKey);
+    console.log('   ➕ 新增AIXX(国产/DeepSeek)供应商');
+    updated++;
+  }
+
+  // 写回
+  try {
+    writeFileSync(zcodeConfigPath, JSON.stringify(config, null, 2));
+    return {
+      configured: true,
+      note: `已配置ZCode供应商，请重启ZCode并在模型选择里选AIXX`,
+      updated,
+    };
+  } catch (e) {
+    console.log(`   ⚠️  写入ZCode配置失败: ${e.message}`);
+    return { configured: false, note: `写入失败: ${e.message}` };
+  }
+}
+
+/**
+ * 写入 Claude Code 配置。
+ *
+ * 往 ~/.claude/settings.json 的 env 块写：
+ *   ANTHROPIC_BASE_URL / ANTHROPIC_AUTH_TOKEN
+ *
+ * 注意：这会覆盖用户已有的 Claude 配置（如果已经配过别的baseURL/token）。
+ * 所以要先检测是否有冲突，冲突时只更新key但保留提示。
+ *
+ * 返回 { configured: true/false, note: '...', overwritten: true/false }
+ */
+export function configureClaudeCode(apiKey) {
+  const claudeSettingsPath = join(homedir(), '.claude', 'settings.json');
+
+  if (!existsSync(claudeSettingsPath)) {
+    return { configured: false, note: '未检测到Claude Code（~/.claude/settings.json不存在），跳过' };
+  }
+
+  const settings = readJsonSafe(claudeSettingsPath);
+  if (!settings || typeof settings !== 'object') {
+    console.log('   ⚠️  Claude settings.json 解析失败，跳过Claude Code配置');
+    return { configured: false, note: 'Claude settings.json 解析失败' };
+  }
+
+  // 备份
+  const backup = backupFile(claudeSettingsPath);
+  if (backup === false) {
+    // 铁律1：备份失败，绝不写入（避免破坏用户现有配置）
+    console.log('   ⚠️  配置备份失败，请手动备份后再试（已跳过Claude Code配置）');
+    return { configured: false, note: '配置备份失败，请手动备份后再试' };
+  }
+  if (backup) {
+    console.log(`   📦 已备份Claude Code配置: ${backup}`);
+  }
+
+  // 检测是否已有冲突配置（不是AIXX的baseURL）
+  let overwritten = false;
+  const oldBase = settings?.env?.ANTHROPIC_BASE_URL;
+  if (oldBase && oldBase !== AIXX_HOST) {
+    overwritten = true;
+  }
+
+  // 幂等 + 写入
+  settings.env = settings.env || {};
+  settings.env.ANTHROPIC_BASE_URL = AIXX_HOST;
+  settings.env.ANTHROPIC_AUTH_TOKEN = apiKey;
+
+  try {
+    writeFileSync(claudeSettingsPath, JSON.stringify(settings, null, 2));
+    return {
+      configured: true,
+      note: overwritten
+        ? '已配置Claude Code（覆盖了你原有的Claude供应商，已备份）'
+        : '已配置Claude Code',
+      overwritten,
+    };
+  } catch (e) {
+    console.log(`   ⚠️  写入Claude Code配置失败: ${e.message}`);
+    return { configured: false, note: `写入失败: ${e.message}` };
+  }
+}
+
+/**
+ * 入口：自动检测并配置所有能找到的agent。
+ * 由 install.js 在拿到apiKey后调用。
+ *
+ * 返回 { zcode, claude } 两个结果对象。
+ */
+export function configureAgents(apiKey) {
+  console.log('\n🔌 配置本地agent（零配置核心）...');
+
+  const zcode = configureZCode(apiKey);
+  if (zcode.configured) {
+    console.log(`   ✅ ZCode: ${zcode.note}`);
+  } else {
+    console.log(`   ⏭️  ZCode: ${zcode.note}`);
+  }
+
+  const claude = configureClaudeCode(apiKey);
+  if (claude.configured) {
+    console.log(`   ✅ Claude Code: ${claude.note}`);
+    if (claude.overwritten) {
+      console.log('   ⚠️  注意：你原有的Claude供应商被AIXX覆盖了。如需恢复，去备份目录找原配置。');
+    }
+  } else {
+    console.log(`   ⏭️  Claude Code: ${claude.note}`);
+  }
+
+  return { zcode, claude };
+}

package/src/utils/env.js

@@ -36,14 +36,28 @@ export function setupEnv(apiKey, baseUrl = DEFAULT_BASE_URL) {
       `export AIXX_BASE_URL="${baseUrl}"`,
     ].join('\n');
 
-    // 检测shell类型
-    const shellConfigs = [
-      join(home, '.zshrc'),
-      join(home, '.bashrc'),
-      join(home, '.bash_profile'),
-    ];
+    // 检测当前用的shell（优先看$SHELL，比按文件存在猜更准）
+    // Mac默认zsh，Linux多是bash。$SHELL是用户登录shell，最可靠。
+    const currentShell = process.env.SHELL || '';
+    let shellConfigs;
+    if (currentShell.includes('zsh')) {
+      // zsh用户：写.zshrc（Mac默认）
+      shellConfigs = [join(home, '.zshrc')];
+    } else if (currentShell.includes('bash')) {
+      // bash用户：Linux写.bashrc，Mac写.bash_profile（Mac的bash读.bash_profile）
+      shellConfigs = platform === 'darwin'
+        ? [join(home, '.bash_profile'), join(home, '.bashrc')]
+        : [join(home, '.bashrc'), join(home, '.bash_profile')];
+    } else {
+      // 检测不到（如fish等），按文件存在兜底
+      shellConfigs = [
+        join(home, '.zshrc'),
+        join(home, '.bashrc'),
+        join(home, '.bash_profile'),
+      ];
+    }
 
-    let written = false;
+    let writtenFile = null;
     for (const conf of shellConfigs) {
       if (existsSync(conf)) {
         // 检查是否已配置过（避免重复）
@@ -51,20 +65,24 @@ export function setupEnv(apiKey, baseUrl = DEFAULT_BASE_URL) {
         if (!existing.includes('AIXX_API_KEY')) {
           appendFileSync(conf, envLines);
           console.log(`   → 已写入 ${conf}`);
+        } else {
+          console.log(`   → ${conf} 已有AIXX配置，跳过`);
         }
-        written = true;
+        writtenFile = conf;
         break;
       }
     }
 
-    if (!written) {
-      // 没找到现成配置文件，写.bashrc
-      const bashrc = join(home, '.bashrc');
-      appendFileSync(bashrc, envLines);
-      console.log(`   → 已写入 ${bashrc}`);
+    if (!writtenFile) {
+      // 没找到现成配置文件，按当前shell创建一个
+      const fallback = currentShell.includes('zsh') ? join(home, '.zshrc') : join(home, '.bashrc');
+      appendFileSync(fallback, envLines);
+      console.log(`   → 已创建并写入 ${fallback}`);
+      writtenFile = fallback;
     }
 
-    console.log('   ⚠️  请运行 source ~/.bashrc 或 source ~/.zshrc 让配置生效');
+    const rcName = writtenFile.split(/[\\/]/).pop();
+    console.log(`   ⚠️  请运行 source ~/${rcName} 让配置生效（或重开终端）`);
   } else {
     // Windows: 写入用户环境变量（用setx）
     console.log('   Windows用户请手动设置环境变量，或运行以下命令（PowerShell）：');

package/templates/SKILL.md

@@ -20,9 +20,9 @@ metadata:
 
 AIXX = "AI的谷歌"。装一个skill，agent就能：
 - 🤖 **调用各种LLM**：DeepSeek/GLM/Kimi/Claude/GPT等，自动选最优
-- 🎨 **生成图片/视频**（2.0）
+- 🎨 **生成图片**：豆包生图（doubao-seedream）
+- 🔍 **搜索 AI skill/工具**：用户说"我要个审美skill"，AIXX去GitHub搜+给中文推荐理由+安装方式（**已上线**）
 - 📊 **查询数据**：社媒数据(TikHub)、电商数据(JustOne)（2.0）
-- 🔍 **搜索GitHub开源工具**，推荐最优+给安装指南（2.0）
 
 **核心价值**：用户不碰key、不碰参数、不碰文档。一切通过对话。
 
@@ -35,6 +35,7 @@ AIXX = "AI的谷歌"。装一个skill，agent就能：
 - 指定了特定模型的请求（"用Claude翻译""用DeepSeek分析"）
 - 查询用量/花费/余额（"我花了多少""还剩多少额度"）
 - 切换模型（"用最便宜的""切到GPT"）
+- **找/推荐 AI skill/工具/agent**（"我要个审美skill""帮我找个开发工具""推荐个翻译agent"）→ 走搜索（见 search.md）
 
 ### 不触发AIXX的场景（用agent自己能力）
 - 简单闲聊、确认、日常对话
@@ -66,6 +67,11 @@ agent判断：需要AI能力吗？
   - 入口：[`./references/chat.md`](./references/chat.md)
   - 覆盖：翻译、写作、分析、问答、代码等，自动选模型或指定模型
 
+- **搜索 AI skill/工具**（AIXX的"AI的谷歌"）
+  - 入口：[`./references/search.md`](./references/search.md)
+  - 覆盖：找skill、推荐工具、发现新AI能力，给中文推荐理由+安装方式
+  - 场景：用户说"我要个X的skill""帮我找个Y工具""推荐个Z agent"
+
 - **用量查询与账户管理**
   - 入口：[`./references/account.md`](./references/account.md)
   - 覆盖：查余额、查花费、查用量、切换默认模型