deepfish-ai 1.0.29 → 2.0.2

package/src/AgentRobot/BaseAgentRobot/utils/AttachmentToolScanner.js

@@ -1,235 +0,0 @@
-const fs = require('fs-extra')
-const path = require('path')
-const { getGlobalNodeModulesPath } = require('./node-root')
-
-class AttachmentToolType {
-  static BASE_SKILL = 'BaseSkill' // 基础技能，提供技能定义的基本结构
-  static CLAW_SKILL = 'ClawSkill' // 爪子技能，提供技能执行的基本结构
-}
-
-class AttachmentToolScanner {
-  // 获取附加工具
-  static getToolCollection(workspace, basespace) {
-    // 从文件中加载附加技能
-    // 动态加载这些文件，获取工具对象
-    const attachTools = []
-    // 先扫描懒加载目录
-    const lazyLoadDir = path.join(__dirname, '../lazy-tools')
-    const lazyFiles = fs.existsSync(lazyLoadDir) ? fs.readdirSync(lazyLoadDir) : []
-    for (const fileName of lazyFiles) {
-      try {
-        const filePath = path.join(lazyLoadDir, fileName)
-        const tool = require(path.resolve(lazyLoadDir, fileName))
-        if (tool) {
-          tool.type = AttachmentToolType.BASE_SKILL
-          tool.location = tool.location || path.dirname(filePath)
-          tool.filePath = tool.filePath || filePath
-          attachTools.push(tool)
-        }
-      } catch (error) {
-        console.error(`加载附加工具失败: ${fileName}`, error)
-      }
-    }
-
-
-    // 1.搜索程序所在目录下的以deepfish-ai-开头的文件夹
-    // 2.搜索程序所在目录下以@deepfish-ai开头的文件夹里的目录
-    // 3.工作目录下node_modules目录下以deepfish-ai-开头的文件夹
-    // 4.工作目录下node_modules目录下以@deepfish-ai开头的文件夹里的目录
-    // 5.工作目录下以deepfish-ai-开头的文件夹
-    // 6.工作目录下以@deepfish-ai开头的文件夹里的目录
-    // 7.工作目录下的js文件
-
-    /**
-     * 附加工具结构：
-     * name: 'BaseSkill',
-     * description: '基础扩展模板，提供扩展的基本结构定义',
-     * location: currentDir, // 扩展文件路径，默认为当前文件所在目录
-     * platform: 'all', // 扩展支持的平台(process.platform)，all或空表示所有平台, win32表示仅支持 Windows, darwin表示仅支持MacOS, linux表示仅支持Linux
-     * descriptions,
-     * functions,
-     */
-    // 1. 子agent创建时，不能拥有其他附加能力
-    // 2. 使用platform过滤
-    const dir1 = path.resolve(__dirname, '../../../../../') // 程序所在目录
-    const dir2 = path.resolve(workspace, './node_modules') // 工作目录下node_modules目录
-    const dir3 = path.resolve(workspace, './') // 工作目录
-    const dir4 = getGlobalNodeModulesPath()
-    const dir5 = path.resolve(basespace, 'skills') // 工作目录的父目录
-    const dir6 = path.resolve(basespace, 'clawSkills') // 工作目录的父目录
-    const result = []
-    const searchDirs = [...new Set([dir1, dir2, dir3, dir4, dir5, dir6])]
-    for (const dirPath of searchDirs) {
-      if (!fs.existsSync(dirPath)) {
-        continue
-      }
-      const fileNames = fs.readdirSync(dirPath)
-      // 查询目录下是否有@deepfish-ai目录
-      fileNames.forEach((dirName) => {
-        if (dirName === '@deepfish-ai') {
-          const deepFishPath = path.resolve(dirPath, '@deepfish-ai')
-          const packageNames = fs.readdirSync(deepFishPath)
-          packageNames.forEach((packageName) => {
-            const mainFile = AttachmentToolScanner._scanDeepFishPackage(
-              deepFishPath,
-              packageName,
-            )
-            if (mainFile) {
-              result.push(mainFile)
-            }
-          })
-        } else if (
-          dirName.startsWith('deepfish-') &&
-          dirName !== 'deepfish-ai'
-        ) {
-          const mainFile = AttachmentToolScanner._scanDeepFishPackage(dirPath, dirName)
-          if (mainFile) {
-            result.push(mainFile)
-          }
-        }
-      })
-    }
-    const fileNames = fs.readdirSync(dir3)
-    fileNames.forEach((fileName) => {
-      if (fileName.endsWith('.js') || fileName.endsWith('.mjs')) {
-        const mainFile = AttachmentToolScanner._scanDeepFishJsFile(dir3, fileName)
-        if (mainFile) {
-          result.push(mainFile)
-        }
-      }
-    })
-    for (const filePath of result) {
-      try {
-        const tool = require(filePath)
-        if (tool) {
-          tool.type = AttachmentToolType.BASE_SKILL
-          tool.location = tool.location || path.dirname(filePath)
-          tool.filePath = tool.filePath || filePath 
-          attachTools.push(tool)
-        }
-      } catch (error) {
-        console.error(`加载附加工具失败: ${filePath}`, error)
-      }
-    }
-    return attachTools
-  }
-
-  static getClawSkillCollection(basespace) {
-    const skillFilePath = path.join(basespace, './clawSkills/clawSkills.json')
-    if (!fs.pathExistsSync(skillFilePath)) {
-      return []
-    } else {
-      const skillJson = fs.readJSONSync(skillFilePath)
-      return (skillJson.skills || []).filter(skill => skill.enable).map((skill) => {
-        return {
-          ...skill,
-          type: AttachmentToolType.CLAW_SKILL
-        }
-      })
-    }
-  }
-
-  static getAttachToolPrompt(toolCollection, clawSkillCollection) {
-    const table = ([].concat(toolCollection).concat(clawSkillCollection))
-      .map(
-        (s) =>
-          `| ${s.name} | ${s.type} | ${s.description || s.extensionDescription} | ${s.location} | ${s.filePath || s.skillFilePath} |`,
-      )
-      .join('\n')
-    if (!table || !table.length) {
-      return '### 暂无可用的Skills'
-    }
-    return `
-### 可以使用的Skills
-可以调用以下Skill来完成用户的请求，Skill的调用方式：
-- 使用用户请求匹配 skill description，
-- 一次只加载一个Skill，优先匹配最具体的Skill
-- 当用户请求不匹配任何Skill描述时，不加载任何Skill
-- 调用 createSubSkillAgent 函数创建子Agent来执行任务
-## Available Skills
-
-| Skill | Type | Description | Location | FilePath |
-|-------|------|-------------|----------|----------|
-${table}
-|-------|------|-------------|----------|----------|
-`
-  }
-
-  static getClawSkillPrompt(clawSkills=[], toolCollection=[], clawSkillCollection=[]) {
-    const table1 = clawSkills
-      .map(
-        (s) =>
-          `| ${s.name} | ${s.type} | ${s.description} | ${s.location} | ${s.skillFilePath} |`,
-      )
-      .join('\n')
-    const table2 = ([].concat(toolCollection).concat(clawSkillCollection))
-      .map(
-        (s) =>
-          `| ${s.name} | ${s.type} | ${s.description || s.extensionDescription} | ${s.location} | ${s.filePath || s.skillFilePath} |`,
-      )
-      .join('\n')
-    let skills1 = clawSkills.length > 0 ? `
-    ### 优先使用的Skills
-可以优先调用以下Skill来完成用户的请求，Skill的调用方式：
-- 使用用户请求匹配 skill description，
-- 一次只加载一个Skill，优先匹配最具体的Skill
-- 当用户请求不匹配任何Skill描述时，不加载任何Skill
-- 使用Skill前先使用readFile函数读取SKILL.md文件获取调用说明，通过仔细阅读说明文件学习Skill的使用方法，直接完成任务，无需创建子Agent来完成任务
-## Available Skills
-
-| Skill | Type | Description | Location | SkillFilePath |
-|-------|------|-------------|----------|---------------|
-${table1}
-|-------|------|-------------|----------|---------------|
-` : '### 无优先使用的Skills'
-  let skills2 = toolCollection.length + clawSkillCollection.length > 0 ?  `
-### 其他可以使用的Skills
-可以调用以下Skill来完成用户的请求，Skill的调用方式：
-- 使用用户请求匹配 skill description，
-- 一次只加载一个Skill，优先匹配最具体的Skill
-- 当用户请求不匹配任何Skill描述时，不加载任何Skill
-- Type类型为'ClawSkill'时，使用Skill前先使用readFile函数读取SKILL.md文件获取调用说明，通过仔细阅读说明文件学习Skill的使用方法，来完成任务
-- Type类型为'BaseSkill'时，使用loadAttachTool函数加载Skill后，该技能中的工具函数会被添加到工具列表中，即可直接调用
-## Available Skills
-
-| Skill | Type | Description | Location | FilePath |
-|-------|------|-------------|----------|----------|
-${table2}
-|-------|------|-------------|----------|----------|
-`: '### 无其他可用的Skills'
-return skills1 + '\n' + skills2
-  }
-
-  // 扫描包
-  static _scanDeepFishPackage(parentDir, packageName) {
-    const dirPath = path.resolve(parentDir, packageName)
-    const packageJsonPath = path.resolve(dirPath, 'package.json')
-    if (fs.pathExistsSync(packageJsonPath)) {
-      const packageJson = fs.readJsonSync(packageJsonPath)
-      if (packageJson.main) {
-        return AttachmentToolScanner._scanDeepFishJsFile(dirPath, packageJson.main)
-      }
-    }
-    return null
-  }
-  // 扫描文件
-  static _scanDeepFishJsFile(parentDir, fileName) {
-    const filePath = path.resolve(parentDir, fileName)
-    if (fs.pathExistsSync(filePath)) {
-      const fileContent = fs.readFileSync(filePath, 'utf-8')
-      if (
-        fileContent.includes('module.exports') &&
-        fileContent.includes('descriptions') &&
-        fileContent.includes('functions')
-      ) {
-        return filePath
-      }
-    }
-    return null
-  }
-}
-
-module.exports = {
-  AttachmentToolScanner,
-  AttachmentToolType,
-}

package/src/AgentRobot/BaseAgentRobot/utils/MessageCompresser.js

@@ -1,236 +0,0 @@
-/**
- * @Author: Roman 306863030@qq.com
- * @Date: 2026-03-16 09:18:05
- * @LastEditors: Roman 306863030@qq.com
- * @LastEditTime: 2026-04-13 11:21:09
- * @FilePath: \deepfish\src\AgentRobot\BaseAgentRobot\utils\MessageCompresser.js
- * @Description: 上下文管理-添加、自动压缩
- * @
- */
-const BrainEvent = require('../BrainEvent.js')
-
-class MessageCompresser {
-  constructor(robotBrain) {
-    this.robotBrain = robotBrain
-    // 最大上下文长度，留10%余量
-    this.maxContextLength = (this.robotBrain.maxContextLength || 32) * 1024 * 0.9
-    // 固定保留最新 X 条消息不压缩（行业最佳实践）
-    this.KEEP_LATEST_COUNT = 3
-  }
-
-  /**
-   * 压缩消息：稳定版策略
-   * 保留：第一条system + 最新3条消息 + 中间压缩为摘要
-   */
-  async compress(messages) {
-    // 空消息直接返回
-    if (!messages || messages.length === 0) return messages
-
-    // 先清理工具调用消息序列，避免历史坏数据触发 400
-    this._normalizeInPlace(messages)
-
-    const currentLength = this._getLength(messages)
-    // 不需要压缩直接返回
-    if (this.maxContextLength !== -1 && currentLength <= this.maxContextLength) {
-      return messages
-    }
-
-    this.robotBrain.emit(BrainEvent.COMPRESS_MESSAGES_BEFORE, messages, currentLength)
-
-    // ---------------------
-    // 核心：安全截取规则
-    // ---------------------
-    const newMessages = []
-    const totalMsg = messages.length
-
-    // 1. 永远保留第一条 system 消息
-    const firstSystem = messages[0]
-    newMessages.push(firstSystem)
-
-    // 2. 消息太少，不压缩
-    if (totalMsg <= this.KEEP_LATEST_COUNT + 1) {
-      this.robotBrain.emit(BrainEvent.COMPRESS_MESSAGES_AFTER, newMessages, this._getLength(newMessages))
-      return [...messages]
-    }
-
-    // 3. 中间需要压缩的区间：第1条 ~ 安全保留尾部起点
-    const compressStart = 1
-    const minTailStart = Math.max(1, totalMsg - this.KEEP_LATEST_COUNT)
-    const safeTailStart = this._findSafeTailStart(messages, minTailStart)
-    const compressEnd = safeTailStart
-    const middleMessages = messages.slice(compressStart, compressEnd)
-
-    // 4. 压缩中间历史
-    if (middleMessages.length > 0) {
-      const summary = await this._getSummary(middleMessages)
-      newMessages.push(summary)
-    }
-
-    // 5. 保留最新消息（不压缩），并保证不会截断 tool_calls 对应关系
-    const latestMessages = messages.slice(safeTailStart)
-    newMessages.push(...latestMessages)
-
-    // 再做一次序列归一化，避免压缩后出现非法 tool 消息
-    const normalized = this._normalizeToolMessageSequence(newMessages)
-
-    // 替换原数组
-    messages.splice(0, messages.length, ...normalized)
-
-    this.robotBrain.emit(BrainEvent.COMPRESS_MESSAGES_AFTER, messages, this._getLength(normalized))
-    return messages
-  }
-
-  /**
-   * 计算安全尾部起点，避免产生孤立的 tool 消息：
-   * - 如果起点落在 tool 消息上，向前回退到触发该 tool 的 assistant(tool_calls)
-   * - 如果 assistant(tool_calls) 后存在任意 tool 消息被保留，则 assistant(tool_calls) 必须一并保留
-   */
-  _findSafeTailStart(messages, minTailStart) {
-    let start = minTailStart
-    while (start > 1) {
-      const current = messages[start]
-      const prev = messages[start - 1]
-
-      if (current?.role === 'tool') {
-        start -= 1
-        continue
-      }
-
-      if (current?.role !== 'tool' && prev?.role === 'tool') {
-        start -= 1
-        continue
-      }
-
-      const hasToolMessagesAfter = messages
-        .slice(start + 1)
-        .some((msg) => msg?.role === 'tool')
-      if (current?.role === 'assistant' && current?.tool_calls && hasToolMessagesAfter) {
-        return start
-      }
-
-      break
-    }
-
-    while (start < messages.length) {
-      const msg = messages[start]
-      if (msg?.role !== 'tool') {
-        break
-      }
-      start += 1
-    }
-
-    return start
-  }
-
-  _normalizeInPlace(messages) {
-    const normalized = this._normalizeToolMessageSequence(messages)
-    if (normalized.length === messages.length && normalized.every((m, i) => m === messages[i])) {
-      return
-    }
-    messages.splice(0, messages.length, ...normalized)
-  }
-
-  _normalizeToolMessageSequence(messages) {
-    const normalized = []
-    let pending = null
-
-    const flushPending = () => {
-      if (!pending) return
-      const hasAllToolReports = pending.callIds.size > 0 && pending.respondedIds.size === pending.callIds.size
-      if (hasAllToolReports) {
-        normalized.push(pending.assistant)
-        normalized.push(...pending.toolReports)
-      }
-      pending = null
-    }
-
-    for (const msg of messages) {
-      if (msg?.role === 'assistant' && Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0) {
-        flushPending()
-        pending = {
-          assistant: msg,
-          toolReports: [],
-          callIds: new Set(msg.tool_calls.map((item) => item?.id).filter(Boolean)),
-          respondedIds: new Set(),
-        }
-        continue
-      }
-
-      if (msg?.role === 'tool') {
-        if (!pending) {
-          continue
-        }
-        if (!msg.tool_call_id || !pending.callIds.has(msg.tool_call_id)) {
-          continue
-        }
-        pending.toolReports.push(msg)
-        pending.respondedIds.add(msg.tool_call_id)
-        continue
-      }
-
-      flushPending()
-      normalized.push(msg)
-    }
-
-    flushPending()
-    return normalized
-  }
-
-  // 计算消息总长度（稳健版）
-  _getLength(messages) {
-    return messages.reduce((total, msg) => {
-      let len = 0
-      if (msg.content) {
-        len += typeof msg.content === 'string'
-          ? msg.content.length
-          : JSON.stringify(msg.content).length
-      }
-      if (msg.tool_calls) {
-        len += JSON.stringify(msg.tool_calls).length
-      }
-      return total + len
-    }, 0)
-  }
-
-  // 生成对话摘要（优化提示词 + 错误兜底）
-  async _getSummary(messages) {
-    const conversationText = messages
-      .map(m => {
-        const role = m.role.toUpperCase()
-        const content = m.content || (m.tool_calls ? '[工具调用]' : '')
-        return `[${role}]: ${content}`
-      })
-      .join('\n')
-
-    const summaryPrompt = `
-请总结以下对话历史，严格遵守规则：
-1. 只保留：用户任务目标、执行结果、关键上下文
-2. 删除：报错、冗余描述、闲聊、过程细节
-3. 摘要必须简洁、完整，保证后续任务能正常继续
-4. 不要多余解释，只输出纯摘要文本
-
-对话历史：
-${conversationText}`
-
-    try {
-      const summary = await this.robotBrain.think(
-        '你是专业的对话摘要助手，只输出精简摘要',
-        summaryPrompt
-      )
-      return {
-        role: 'system',
-        content: `【历史对话摘要】：${summary}`,
-      }
-    } catch (error) {
-      // 降级方案：手动截取
-      let manual = '【历史摘要（降级）】：'
-      messages.slice(0, 4).forEach(m => {
-        const c = m.content || ''
-        manual += `${m.role}：${c.slice(0, 80)}... `
-      })
-      return { role: 'system', content: manual }
-    }
-  }
-}
-
-module.exports = MessageCompresser

package/src/AgentRobot/BaseAgentRobot/utils/aiConsole.js

@@ -1,74 +0,0 @@
-const chalk = require('chalk')
-
-const aiConsole = {
-  // 日志相关工具函数
-  logInfo(message) {
-    this.log(message, '#6dd2ea')
-  },
-
-  logSuccess(message) {
-    this.log(message, '#9bed7f')
-  },
-
-  logError(message) {
-    this.log(message, '#ed7f7f')
-  },
-
-  logWarning(message) {
-    this.log(message, '#f2c94c')
-  },
-
-  logDisabled(message) {
-    this.log(message, '#999999')
-  },
-
-  writeLine(msg1, msg2 = '', color = 'blue') {
-    if (color === 'blue') {
-      process.stdout.write('\r' + chalk.hex('#6dd2ea')(msg1) + ' ' + msg2)
-    } else if (color === 'green') {
-      process.stdout.write('\r' + chalk.hex('#9bed7f')(msg1) + ' ' + msg2)
-    } else if (color === 'red') {
-      process.stdout.write('\r' + chalk.hex('#ed7f7f')(msg1) + ' ' + msg2)
-    } else {
-      process.stdout.write('\r' + chalk.hex(color)(msg1) + ' ' + msg2)
-    }
-  },
-
-  // 流式输出
-  async streamOutput(text, color = '#9bed7f') {
-    process.stdout.write(chalk.hex(color)(text))
-  },
-
-  // 流式换行
-  async streamLineBreak() {
-    process.stdout.write('\n')
-  },
-
-  loading(label = 'Thinking...') {
-    let animationInterval
-    const spinners = ['|', '/', '-', '\\']
-    let spinnerIndex = 0
-    process.stdout.write('\r')
-    animationInterval = setInterval(() => {
-      this.writeLine(spinners[spinnerIndex], label)
-      spinnerIndex = (spinnerIndex + 1) % spinners.length
-    }, 200)
-    return (endLabel, isError = false) => {
-      clearInterval(animationInterval)
-      if (endLabel) {
-        this.writeLine(endLabel, '', isError ? 'red' : 'green')
-      }
-      process.stdout.write('\r\n')
-    }
-  },
-
-  log(msg, color) {
-    if (!color) {
-      console.log(msg)
-    } else {
-      console.log(chalk.hex(color)(msg))
-    }
-  },
-}
-
-module.exports = aiConsole

package/src/AgentRobot/BaseAgentRobot/utils/aiInquirer.js

@@ -1,78 +0,0 @@
-const inquirer = require('inquirer').default
-
-// 判断问答
-async function askConfirm(message, defaultVal = true, opt = {}) {
-  const questions = [
-    {
-      type: 'confirm',
-      name: 'confirm',
-      message,
-      default: defaultVal,
-      ...opt
-    }
-  ]
-  const answers = await inquirer.prompt(questions)
-  return answers['confirm']
-}
-
-// 选择问答
-async function askList(message, choices, defaultVal = 0, opt = {}) {
-  const questions = [
-    {
-      type: 'list',
-      name: 'list',
-      message,
-      choices,
-      default: defaultVal,
-      ...opt
-    }
-  ]
-  const answers = await inquirer.prompt(questions)
-  return answers['list']
-}
-
-// 输入问答
-async function askInput(message, defaultVal = '', opt = {}) {
-  const questions = [
-    {
-      type: 'input',
-      name: 'input',
-      message,
-      default: defaultVal,
-      ...opt
-    },
-  ]
-  const answers = await inquirer.prompt(questions)
-  return answers['input']
-}
-
-// 输入数字
-async function askNumber(message, defaultVal = 0, opt = {}) {
-  const questions = [
-    {
-      type: 'number',
-      name: 'number',
-      message,
-      default: defaultVal,
-      ...opt
-    },
-  ]
-  const answers = await inquirer.prompt(questions)
-  return answers['number']
-}
-
-// 输入任何
-function askAny(questions) {
-  return inquirer.prompt(questions)
-}
-
-const aiInquirer = {
-  askAny,
-  askConfirm,
-  askList,
-  askInput,
-  askNumber,
-}
-
-
-module.exports = aiInquirer