autosnippet 3.2.7 → 3.2.9

package/lib/service/chat/TaskPipeline.js

@@ -1,357 +0,0 @@
-/**
- * TaskPipeline — 轻量级 DAG 任务编排引擎
- *
- * 从旧版 ToolOrchestrator 精简而来，保留核心 DAG 能力：
- *   1. 步骤间依赖声明（dependsOn）
- *   2. 参数引用映射（'stepName:path' / 'input:path'）
- *   3. 拓扑排序 → 同层并行执行（Promise.all）
- *   4. 错误策略（continue / fail）+ 重试
- *   5. 条件跳过（when 回调）
- *
- * 与 ChatAgent / ToolRegistry 的关系：
- *   - TaskPipeline 不直接持有 ToolRegistry 引用
- *   - 通过 executor 函数抽象：executor(toolName, params) → result
- *   - ChatAgent 传入 this.executeTool.bind(this) 即可
- *
- * 使用示例：
- * ```js
- * const pipeline = new TaskPipeline('bootstrap_full_pipeline', [
- *   { name: 'bootstrap', tool: 'bootstrap_knowledge', params: { maxFiles: 500, loadSkills: true } },
- *   { name: 'enrich',    tool: 'enrich_candidate',
- *     params: { candidateIds: 'bootstrap:bootstrapCandidates.ids' },
- *     dependsOn: ['bootstrap'] },
- *   { name: 'refine',    tool: 'refine_bootstrap_candidates',
- *     params: { userPrompt: 'input:refinePrompt' },
- *     dependsOn: ['enrich'],
- *     when: (ctx) => ctx._results.bootstrap?.bootstrapCandidates?.created > 0 },
- * ]);
- * const result = await pipeline.execute(executor, { refinePrompt: '...' });
- * ```
- *
- * 步骤定义 (StepDef):
- * @typedef {object} StepDef
- * @property {string}   name          — 步骤唯一名称
- * @property {string}   tool          — 工具名称（传给 executor）
- * @property {object}   [params={}]   — 参数对象（支持引用：'stepName:path' / 'input:path' / function(ctx)）
- * @property {string[]} [dependsOn]   — 依赖步骤名称数组
- * @property {Function} [when]        — 条件回调 (ctx) => boolean，返回 false 则跳过此步骤
- * @property {string}   [errorStrategy='fail'] — 'fail' 中断 | 'continue' 继续
- * @property {number}   [retries=1]   — 最大执行次数（含首次）
- * @property {number}   [retryDelay=0]— 重试间隔 ms
- * @property {Function} [transform]   — (result, ctx) => transformedResult，对工具返回值后处理
- */
-
-import Logger from '../../infrastructure/logging/Logger.js';
-
-export class TaskPipeline {
-  /** @type {string} */
-  #id;
-  /** @type {StepDef[]} */
-  #steps;
-  /** @type {import('../../infrastructure/logging/Logger.js').default} */
-  #logger;
-
-  /**
-   * @param {string} id — 管线唯一标识
-   * @param {StepDef[]} steps — 步骤定义数组
-   */
-  constructor(id, steps) {
-    this.#id = id;
-    this.#steps = steps;
-    this.#logger = Logger.getInstance();
-    this.#validate();
-  }
-
-  // ─── 公共 API ─────────────────────────────────────────
-
-  /** 管线 ID */
-  get id() {
-    return this.#id;
-  }
-
-  /** 步骤数 */
-  get size() {
-    return this.#steps.length;
-  }
-
-  /**
-   * 执行管线
-   *
-   * @param {(toolName: string, params: object) => Promise<any>} executor
-   *   工具执行函数，通常是 ChatAgent.executeTool.bind(chatAgent)
-   * @param {object} [inputs={}] — 管线初始输入（通过 'input:key' 引用）
-   * @returns {Promise<PipelineResult>}
-   *
-   * @typedef {object} PipelineResult
-   * @property {boolean}  success   — 全部步骤成功（或被允许失败）
-   * @property {string}   pipelineId
-   * @property {object}   outputs   — { stepName: result }
-   * @property {object[]} trace     — 执行轨迹 [{ step, status, durationMs, error? }]
-   * @property {number}   durationMs
-   */
-  async execute(executor, inputs = {}) {
-    const t0 = Date.now();
-    const ctx = {
-      _pipelineId: this.#id,
-      _inputs: inputs,
-      _results: {},
-    };
-    const trace = [];
-
-    // 拓扑排序 → 按层并行
-    const phases = this.#topologicalSort();
-
-    this.#logger.info(
-      `[TaskPipeline] "${this.#id}" start — ${this.#steps.length} steps, ${phases.length} phases`
-    );
-
-    for (const phase of phases) {
-      const promises = phase.map((stepName) => this.#executeStep(stepName, executor, ctx, trace));
-      const results = await Promise.allSettled(promises);
-
-      // 检查是否有 fail 策略的步骤失败
-      for (const r of results) {
-        if (r.status === 'rejected') {
-          this.#logger.error(`[TaskPipeline] "${this.#id}" aborted`, { error: r.reason?.message });
-          return {
-            success: false,
-            pipelineId: this.#id,
-            outputs: ctx._results,
-            trace,
-            durationMs: Date.now() - t0,
-            error: r.reason?.message,
-          };
-        }
-      }
-    }
-
-    this.#logger.info(`[TaskPipeline] "${this.#id}" done — ${Date.now() - t0}ms`);
-    return {
-      success: true,
-      pipelineId: this.#id,
-      outputs: ctx._results,
-      trace,
-      durationMs: Date.now() - t0,
-    };
-  }
-
-  // ─── 内部实现 ─────────────────────────────────────────
-
-  /**
-   * 执行单个步骤（含 when 判断、重试、erorrStrategy）
-   */
-  async #executeStep(stepName, executor, ctx, trace) {
-    const step = this.#steps.find((s) => s.name === stepName);
-    const t0 = Date.now();
-
-    // ── when 条件 ──
-    if (step.when && !step.when(ctx)) {
-      const entry = { step: stepName, status: 'skipped', durationMs: 0 };
-      trace.push(entry);
-      this.#logger.debug(`[TaskPipeline] Step "${stepName}" skipped (when=false)`);
-      ctx._results[stepName] = { _skipped: true };
-      return;
-    }
-
-    // ── 解析参数 ──
-    const params = this.#resolveParams(step.params || {}, ctx);
-
-    // ── 执行（含重试）──
-    const maxAttempts = step.retries || 1;
-    let lastError;
-
-    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-      try {
-        this.#logger.debug(`[TaskPipeline] Step "${stepName}" attempt ${attempt}/${maxAttempts}`);
-        let result = await executor(step.tool, params);
-
-        // transform 后处理
-        if (step.transform) {
-          result = step.transform(result, ctx);
-        }
-
-        ctx._results[stepName] = result;
-        trace.push({ step: stepName, status: 'ok', durationMs: Date.now() - t0, attempt });
-        return;
-      } catch (err) {
-        lastError = err;
-        if (attempt < maxAttempts && step.retryDelay) {
-          await new Promise((r) => setTimeout(r, step.retryDelay));
-        }
-      }
-    }
-
-    // ── 全部重试失败 ──
-    const errorMsg = lastError?.message || 'unknown error';
-    trace.push({
-      step: stepName,
-      status: 'failed',
-      durationMs: Date.now() - t0,
-      error: errorMsg,
-      attempts: maxAttempts,
-    });
-    ctx._results[stepName] = { _error: errorMsg };
-
-    if ((step.errorStrategy || 'fail') === 'fail') {
-      throw new Error(`[TaskPipeline] Step "${stepName}" failed: ${errorMsg}`);
-    }
-    // errorStrategy: 'continue' → 不抛异常
-    this.#logger.warn(`[TaskPipeline] Step "${stepName}" failed (continue): ${errorMsg}`);
-  }
-
-  /**
-   * 解析参数引用
-   *
-   * 规则:
-   *   'input:key'       → ctx._inputs.key
-   *   'stepName:path'   → ctx._results.stepName.path (支持嵌套 a.b.c)
-   *   function(ctx)     → 执行函数获取值
-   *   其他              → 字面值
-   */
-  #resolveParams(params, ctx) {
-    const resolved = {};
-    for (const [key, value] of Object.entries(params)) {
-      if (typeof value === 'function') {
-        resolved[key] = value(ctx);
-      } else if (typeof value === 'string' && value.includes(':')) {
-        const colonIdx = value.indexOf(':');
-        const source = value.substring(0, colonIdx);
-        const path = value.substring(colonIdx + 1);
-
-        if (source === 'input') {
-          resolved[key] = this.#getNestedValue(ctx._inputs, path);
-        } else if (ctx._results[source] !== undefined) {
-          resolved[key] = this.#getNestedValue(ctx._results[source], path);
-        } else {
-          // 无法解析 → 保留原始字符串（可能是普通 URL 等含冒号的值）
-          resolved[key] = value;
-        }
-      } else {
-        resolved[key] = value;
-      }
-    }
-    return resolved;
-  }
-
-  /**
-   * 嵌套取值: 'a.b.c' → obj.a.b.c
-   */
-  #getNestedValue(obj, path) {
-    if (obj == null) {
-      return undefined;
-    }
-    return path.split('.').reduce((acc, key) => acc?.[key], obj);
-  }
-
-  /**
-   * 拓扑排序 → 分层（同层可并行）
-   * @returns {string[][]} phases — [[stepA, stepB], [stepC], ...]
-   */
-  #topologicalSort() {
-    const graph = new Map();
-    for (const step of this.#steps) {
-      graph.set(step.name, step.dependsOn || []);
-    }
-
-    // 检测环 + 拓扑排序
-    const visited = new Set();
-    const visiting = new Set();
-    const sorted = [];
-
-    const visit = (name) => {
-      if (visited.has(name)) {
-        return;
-      }
-      if (visiting.has(name)) {
-        throw new Error(`[TaskPipeline] Circular dependency: ${name}`);
-      }
-      visiting.add(name);
-      for (const dep of graph.get(name) || []) {
-        visit(dep);
-      }
-      visiting.delete(name);
-      visited.add(name);
-      sorted.push(name);
-    };
-
-    for (const name of graph.keys()) {
-      visit(name);
-    }
-
-    // 分层：按最大依赖深度
-    const depth = new Map();
-    for (const name of sorted) {
-      const deps = graph.get(name) || [];
-      const d = deps.length === 0 ? 0 : Math.max(...deps.map((dep) => (depth.get(dep) || 0) + 1));
-      depth.set(name, d);
-    }
-
-    const maxDepth = Math.max(0, ...depth.values());
-    const phases = Array.from({ length: maxDepth + 1 }, () => []);
-    for (const [name, d] of depth) {
-      phases[d].push(name);
-    }
-
-    return phases.filter((p) => p.length > 0);
-  }
-
-  /**
-   * 校验步骤定义
-   */
-  #validate() {
-    const names = new Set();
-    for (const step of this.#steps) {
-      if (!step.name) {
-        throw new Error('[TaskPipeline] Step must have a name');
-      }
-      if (!step.tool) {
-        throw new Error(`[TaskPipeline] Step "${step.name}" must have a tool`);
-      }
-      if (names.has(step.name)) {
-        throw new Error(`[TaskPipeline] Duplicate step name: "${step.name}"`);
-      }
-      names.add(step.name);
-    }
-    // 检查 dependsOn 引用是否存在
-    for (const step of this.#steps) {
-      for (const dep of step.dependsOn || []) {
-        if (!names.has(dep)) {
-          throw new Error(`[TaskPipeline] Step "${step.name}" depends on unknown step "${dep}"`);
-        }
-      }
-    }
-  }
-
-  /**
-   * 获取管线的描述信息（用于调试/日志）
-   */
-  describe() {
-    const phases = this.#topologicalSort();
-    return {
-      id: this.#id,
-      steps: this.#steps.map((s) => ({
-        name: s.name,
-        tool: s.tool,
-        dependsOn: s.dependsOn || [],
-        errorStrategy: s.errorStrategy || 'fail',
-        hasWhen: !!s.when,
-      })),
-      phases: phases.map((p, i) => ({ phase: i, parallel: p })),
-    };
-  }
-}
-
-// ─── 便捷工厂函数 ────────────────────────────────────────
-
-/**
- * 快速创建管线（函数式 API）
- *
- * @param {string} id
- * @param {StepDef[]} steps
- * @returns {TaskPipeline}
- */
-export function createPipeline(id, steps) {
-  return new TaskPipeline(id, steps);
-}
-
-export default TaskPipeline;

package/lib/service/chat/WorkingMemory.js

@@ -1,357 +0,0 @@
-/**
- * WorkingMemory — 会话级工作记忆 (Tier 1)
- *
- * @deprecated Phase 3: 已合并入 ActiveContext (lib/service/chat/memory/ActiveContext.js)
- *   - Scratchpad + 工具压缩策略 + buildContext + distill 已迁入 ActiveContext
- *   - 本文件保留做向后兼容，新代码请使用 ActiveContext
- *
- * 管理单次 ChatAgent.execute() 中的上下文压缩与关键发现暂存。
- *
- * 策略:
- *   1. 最近 N 轮工具结果保留原文 (由 ContextWindow 自然携带)
- *   2. 更早的工具结果自动压缩为摘要 (≤200 tokens/条)
- *   3. Scratchpad: Agent 通过 note_finding 工具主动标记关键发现
- *   4. 蒸馏: execute 结束时提取结构化数据供 EpisodicMemory 使用
- *
- * 生命周期: 与单次 execute() 调用一致，不持久化。
- *
- * @module WorkingMemory
- */
-
-import Logger from '../../infrastructure/logging/Logger.js';
-
-/**
- * 工具特化压缩策略
- * 不同工具返回不同结构，压缩时保留最有价值的部分
- */
-const TOOL_COMPRESS_STRATEGIES = {
-  search_project_code(result) {
-    if (typeof result !== 'object') {
-      return String(result).substring(0, 600);
-    }
-    const matches = result.matches || [];
-    const batchResults = result.batchResults || {};
-
-    const lines = [];
-    // 单模式搜索
-    if (matches.length > 0) {
-      lines.push(`搜索到 ${matches.length} 个匹配`);
-      const fileGroups = {};
-      for (const m of matches) {
-        if (!fileGroups[m.file]) {
-          fileGroups[m.file] = [];
-        }
-        fileGroups[m.file].push(m.line);
-      }
-      for (const [file, lineNums] of Object.entries(fileGroups).slice(0, 8)) {
-        lines.push(`  ${file}: L${lineNums.slice(0, 3).join(',')}`);
-      }
-    }
-    // 批量搜索
-    for (const [pattern, sub] of Object.entries(batchResults).slice(0, 5)) {
-      const subMatches = sub.matches || [];
-      lines.push(`  [${pattern}] ${subMatches.length} 个匹配`);
-      for (const m of subMatches.slice(0, 3)) {
-        lines.push(`    ${m.file}:${m.line}`);
-      }
-    }
-    return lines.join('\n');
-  },
-
-  read_project_file(result) {
-    if (typeof result !== 'object') {
-      return String(result).substring(0, 600);
-    }
-    // 批量读取结果
-    if (result.files) {
-      const lines = [`读取 ${result.files.length} 个文件`];
-      for (const f of result.files.slice(0, 5)) {
-        const totalLines = (f.content || '').split('\n').length;
-        lines.push(`  ${f.path} (${totalLines} 行)`);
-      }
-      return lines.join('\n');
-    }
-    // 单文件结果
-    const content = result.content || String(result);
-    const totalLines = content.split('\n').length;
-    return `文件 ${result.path || '?'} (${totalLines} 行)`;
-  },
-
-  get_class_info(result) {
-    if (typeof result !== 'object') {
-      return String(result).substring(0, 600);
-    }
-    const lines = [`类 ${result.className || '?'}`];
-    if (result.superClass) {
-      lines.push(`  继承: ${result.superClass}`);
-    }
-    if (result.protocols?.length) {
-      lines.push(`  协议: ${result.protocols.join(', ')}`);
-    }
-    if (result.methods?.length) {
-      lines.push(`  方法数: ${result.methods.length}`);
-    }
-    if (result.properties?.length) {
-      lines.push(`  属性数: ${result.properties.length}`);
-    }
-    return lines.join('\n');
-  },
-
-  get_class_hierarchy(result) {
-    if (typeof result !== 'object') {
-      return String(result).substring(0, 600);
-    }
-    const classes = result.classes || result.hierarchy || [];
-    return `类层级: ${Array.isArray(classes) ? classes.length : 0} 个类`;
-  },
-
-  get_project_overview(result) {
-    if (typeof result !== 'object') {
-      return String(result).substring(0, 800);
-    }
-    return JSON.stringify(result).substring(0, 800);
-  },
-
-  list_project_structure(result) {
-    if (typeof result !== 'object') {
-      return String(result).substring(0, 600);
-    }
-    const entries = result.entries || result.children || [];
-    return `目录结构: ${Array.isArray(entries) ? entries.length : 0} 个条目`;
-  },
-};
-
-/**
- * 默认压缩 — 截断到 maxChars
- */
-function defaultCompress(result, maxChars = 600) {
-  const str = typeof result === 'string' ? result : JSON.stringify(result);
-  if (str.length <= maxChars) {
-    return str;
-  }
-  return `${str.substring(0, maxChars)}…(truncated)`;
-}
-
-export class WorkingMemory {
-  /** @type {Array<{toolName: string, result: any, round: number, timestamp: number}>} */
-  #recentObservations = [];
-
-  /** @type {Array<{toolName: string, round: number, summary: string}>} */
-  #compressedObservations = [];
-
-  /**
-   * Scratchpad — Agent 主动标记的关键发现
-   * @type {Array<{finding: string, evidence: string, importance: number, round: number}>}
-   */
-  #scratchpad = [];
-
-  /** @type {number} 保留最近 N 轮原始观察 */
-  #maxRecentRounds = 3;
-
-  /** @type {number} 总观察计数 */
-  #totalObservations = 0;
-
-  /** @type {import('../../infrastructure/logging/Logger.js').default} */
-  #logger;
-
-  /**
-   * @param {object} [options]
-   * @param {number} [options.maxRecentRounds=3] - 保留最近 N 轮原始结果
-   */
-  constructor(options = {}) {
-    this.#maxRecentRounds = options.maxRecentRounds ?? 3;
-    this.#logger = Logger.getInstance();
-  }
-
-  // ─── 核心操作 ──────────────────────────────────────────
-
-  /**
-   * 记录工具调用结果 (Observe)
-   *
-   * 自动执行滑动窗口压缩:
-   * - 最新的 maxRecentRounds 轮保留原文 (由 ContextWindow 内部携带)
-   * - 更早轮次的结果自动压缩为摘要
-   *
-   * @param {string} toolName
-   * @param {*} result - 工具返回的原始结果
-   * @param {number} round - 当前迭代轮次
-   */
-  observe(toolName, result, round) {
-    this.#totalObservations++;
-
-    this.#recentObservations.push({
-      toolName,
-      result,
-      round,
-      timestamp: Date.now(),
-    });
-
-    // 滑动窗口压缩
-    while (this.#recentObservations.length > this.#maxRecentRounds) {
-      const oldest = this.#recentObservations.shift();
-      const summary = this.#compress(oldest);
-      this.#compressedObservations.push(summary);
-    }
-  }
-
-  /**
-   * Agent 主动记录关键发现 (note_finding 工具入口)
-   *
-   * @param {string} finding - 关键发现描述
-   * @param {string} [evidence] - 证据 (文件路径:行号)
-   * @param {number} [importance=5] - 重要性 1-10
-   * @param {number} [round=0] - 当前轮次
-   */
-  noteKeyFinding(finding, evidence = '', importance = 5, round = 0) {
-    this.#scratchpad.push({
-      finding,
-      evidence,
-      importance: Math.min(10, Math.max(1, importance)),
-      round,
-    });
-
-    this.#logger.debug(
-      `[WorkingMemory] 📌 noted finding (${importance}/10): ${finding.substring(0, 80)}`
-    );
-  }
-
-  // ─── 上下文构建 ────────────────────────────────────────
-
-  /**
-   * 构建当前 Working Memory 的上下文快照
-   * 用于注入到 system prompt 或 user nudge 中
-   *
-   * @returns {string} Markdown 格式的上下文块，空字符串表示无内容
-   */
-  buildContext() {
-    const parts = [];
-
-    // §1: Scratchpad (最高优先级 — 不会被压缩)
-    if (this.#scratchpad.length > 0) {
-      const sorted = [...this.#scratchpad].sort((a, b) => b.importance - a.importance);
-      parts.push('## 📌 已确认的关键发现');
-      for (const f of sorted) {
-        const badge = f.importance >= 8 ? '⚠️' : f.importance >= 5 ? '📋' : '💡';
-        let line = `- ${badge} [${f.importance}/10] ${f.finding}`;
-        if (f.evidence) {
-          line += ` (${f.evidence})`;
-        }
-        parts.push(line);
-      }
-    }
-
-    // §2: 压缩后的旧观察摘要 (中等优先级)
-    if (this.#compressedObservations.length > 0) {
-      parts.push('## 📂 之前的探索摘要');
-      // 只展示最近 15 条压缩摘要，避免膨胀
-      const recent = this.#compressedObservations.slice(-15);
-      for (const s of recent) {
-        parts.push(`- [R${s.round}|${s.toolName}] ${s.summary.substring(0, 200)}`);
-      }
-      if (this.#compressedObservations.length > 15) {
-        parts.push(`  …(还有 ${this.#compressedObservations.length - 15} 条更早的观察)`);
-      }
-    }
-
-    // 最近原始结果由 ContextWindow 的对话历史自然携带，不重复注入
-    return parts.join('\n');
-  }
-
-  // ─── 蒸馏 (Working → Episodic) ─────────────────────────
-
-  /**
-   * 蒸馏 Working Memory 为结构化报告
-   * 在 Agent execute 结束时调用，结果写入 EpisodicMemory
-   *
-   * @returns {{
-   *   keyFindings: Array<{finding: string, evidence: string, importance: number}>,
-   *   toolCallSummary: string[],
-   *   totalObservations: number,
-   *   compressedCount: number,
-   * }}
-   */
-  distill() {
-    return {
-      keyFindings: this.#scratchpad.map((f) => ({
-        finding: f.finding,
-        evidence: f.evidence,
-        importance: f.importance,
-      })),
-      toolCallSummary: this.#compressedObservations.map(
-        (s) => `[${s.toolName}] ${s.summary.substring(0, 150)}`
-      ),
-      totalObservations: this.#totalObservations,
-      compressedCount: this.#compressedObservations.length,
-    };
-  }
-
-  // ─── 查询 ─────────────────────────────────────────────
-
-  /**
-   * 获取 scratchpad 中的关键发现数量
-   * @returns {number}
-   */
-  get scratchpadSize() {
-    return this.#scratchpad.length;
-  }
-
-  /**
-   * 获取总观察数
-   * @returns {number}
-   */
-  get totalObservations() {
-    return this.#totalObservations;
-  }
-
-  /**
-   * 获取 scratchpad 中的高重要性发现
-   * @param {number} [minImportance=7]
-   * @returns {Array<{finding: string, evidence: string, importance: number}>}
-   */
-  getHighPriorityFindings(minImportance = 7) {
-    return this.#scratchpad
-      .filter((f) => f.importance >= minImportance)
-      .sort((a, b) => b.importance - a.importance);
-  }
-
-  /**
-   * 清空 WorkingMemory — 释放内存
-   * 在 Agent execute 结束后调用，避免残留引用导致内存泄漏
-   */
-  clear() {
-    this.#recentObservations.length = 0;
-    this.#compressedObservations.length = 0;
-    this.#scratchpad.length = 0;
-    this.#totalObservations = 0;
-  }
-
-  // ─── 内部 ─────────────────────────────────────────────
-
-  /**
-   * 工具结果压缩 — 使用特化策略
-   * @param {{toolName: string, result: any, round: number}} observation
-   * @returns {{toolName: string, round: number, summary: string}}
-   */
-  #compress(observation) {
-    const strategy = TOOL_COMPRESS_STRATEGIES[observation.toolName];
-    let summary;
-
-    try {
-      if (strategy) {
-        summary = strategy(observation.result);
-      } else {
-        summary = defaultCompress(observation.result);
-      }
-    } catch {
-      summary = defaultCompress(observation.result);
-    }
-
-    return {
-      toolName: observation.toolName,
-      round: observation.round,
-      summary,
-    };
-  }
-}
-
-export default WorkingMemory;