evo-skills 0.1.0

package/src/config/index.ts

@@ -0,0 +1,220 @@
+import { cosmiconfig } from 'cosmiconfig';
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+import type { EVOConfig, ProjectConfig } from '../types/index.js';
+import { DEFAULT_CONFIG } from './defaults.js';
+
+const MODULE_NAME = 'evo';
+const GLOBAL_CONFIG_DIR = join(homedir(), '.evo');
+const GLOBAL_CONFIG_FILE = join(GLOBAL_CONFIG_DIR, 'settings.toml');
+
+/**
+ * 配置管理器
+ */
+export class ConfigManager {
+  private globalConfig: EVOConfig;
+  private projectConfig: ProjectConfig | null = null;
+  private projectRoot: string | null = null;
+
+  constructor() {
+    this.globalConfig = { ...DEFAULT_CONFIG };
+  }
+
+  /**
+   * 初始化配置管理器
+   */
+  async init(projectRoot?: string): Promise<void> {
+    // 加载全局配置
+    await this.loadGlobalConfig();
+
+    // 如果指定了项目根目录，加载项目配置
+    if (projectRoot) {
+      this.projectRoot = projectRoot;
+      await this.loadProjectConfig();
+    }
+  }
+
+  /**
+   * 加载全局配置
+   */
+  private async loadGlobalConfig(): Promise<void> {
+    const explorer = cosmiconfig(MODULE_NAME, {
+      searchPlaces: [
+        'settings.toml',
+        '.eorc',
+        '.eorc.json',
+        '.eorc.yaml',
+        '.eorc.yml',
+        'package.json',
+      ],
+    });
+
+    try {
+      const result = await explorer.search(GLOBAL_CONFIG_DIR);
+      if (result && !result.isEmpty) {
+        this.globalConfig = this.mergeConfig(DEFAULT_CONFIG, result.config as EVOConfig);
+      }
+    } catch {
+      // 配置文件不存在或格式错误，使用默认配置
+    }
+  }
+
+  /**
+   * 加载项目配置
+   */
+  private async loadProjectConfig(): Promise<void> {
+    if (!this.projectRoot) return;
+
+    const projectConfigPath = join(this.projectRoot, '.evo', 'config', 'settings.toml');
+    const explorer = cosmiconfig(MODULE_NAME, {
+      searchPlaces: [projectConfigPath],
+    });
+
+    try {
+      const result = await explorer.search(this.projectRoot);
+      if (result && !result.isEmpty) {
+        this.projectConfig = result.config as ProjectConfig;
+      }
+    } catch {
+      // 项目配置不存在
+    }
+  }
+
+  /**
+   * 深度合并配置对象
+   */
+  private mergeConfig<T extends object>(base: T, override: Partial<T>): T {
+    const result = { ...base };
+
+    for (const key in override) {
+      if (Object.prototype.hasOwnProperty.call(override, key)) {
+        const baseValue = base[key];
+        const overrideValue = override[key];
+
+        if (
+          typeof baseValue === 'object' &&
+          baseValue !== null &&
+          !Array.isArray(baseValue) &&
+          typeof overrideValue === 'object' &&
+          overrideValue !== null &&
+          !Array.isArray(overrideValue)
+        ) {
+          (result as Record<string, unknown>)[key] = this.mergeConfig(
+            baseValue as object,
+            overrideValue as object
+          );
+        } else if (overrideValue !== undefined) {
+          (result as Record<string, unknown>)[key] = overrideValue;
+        }
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * 获取全局配置
+   */
+  getGlobalConfig(): EVOConfig {
+    return { ...this.globalConfig };
+  }
+
+  /**
+   * 获取项目配置
+   */
+  getProjectConfig(): ProjectConfig | null {
+    return this.projectConfig ? { ...this.projectConfig } : null;
+  }
+
+  /**
+   * 获取 origin skill 路径列表
+   */
+  getOriginPaths(): string[] {
+    return this.globalConfig.origin_paths.paths.map((p) =>
+      p.startsWith('~') ? p.replace('~', homedir()) : resolve(p)
+    );
+  }
+
+  /**
+   * 获取评估器配置
+   */
+  getEvaluatorConfig(): EVOConfig['evaluator'] {
+    return { ...this.globalConfig.evaluator };
+  }
+
+  /**
+   * 获取 patch 配置
+   */
+  getPatchConfig(): EVOConfig['patch'] {
+    return { ...this.globalConfig.patch };
+  }
+
+  /**
+   * 获取 journal 配置
+   */
+  getJournalConfig(): EVOConfig['journal'] {
+    return { ...this.globalConfig.journal };
+  }
+
+  /**
+   * 检查 skill 是否在项目中被冻结
+   */
+  isSkillFrozen(skillId: string): boolean {
+    if (!this.projectConfig) return false;
+    const skillConfig = this.projectConfig.skills[skillId];
+    return skillConfig?.auto_optimize === false;
+  }
+
+  /**
+   * 获取 skill 允许的 patch 类型
+   */
+  getAllowedPatchTypes(skillId: string): string[] {
+    if (!this.projectConfig) return this.globalConfig.patch.allowed_types;
+    const skillConfig = this.projectConfig.skills[skillId];
+    return skillConfig?.allowed_patch_types ?? this.globalConfig.patch.allowed_types;
+  }
+
+  /**
+   * 创建默认全局配置文件
+   */
+  ensureGlobalConfig(): void {
+    if (!existsSync(GLOBAL_CONFIG_DIR)) {
+      mkdirSync(GLOBAL_CONFIG_DIR, { recursive: true });
+    }
+
+    if (!existsSync(GLOBAL_CONFIG_FILE)) {
+      const tomlContent = this.configToToml(DEFAULT_CONFIG);
+      writeFileSync(GLOBAL_CONFIG_FILE, tomlContent, 'utf-8');
+    }
+  }
+
+  /**
+   * 简单的配置转 TOML（仅支持一层嵌套）
+   */
+  private configToToml(config: object, indent = 0): string {
+    let result = '';
+    const prefix = '  '.repeat(indent);
+
+    for (const [key, value] of Object.entries(config)) {
+      if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+        result += `${prefix}[${key}]\n`;
+        result += this.configToToml(value as object, indent + 1);
+        result += '\n';
+      } else if (Array.isArray(value)) {
+        result += `${prefix}${key} = [${value.map((v) => `"${v}"`).join(', ')}]\n`;
+      } else if (typeof value === 'string') {
+        result += `${prefix}${key} = "${value}"\n`;
+      } else if (typeof value === 'boolean') {
+        result += `${prefix}${key} = ${value}\n`;
+      } else if (typeof value === 'number') {
+        result += `${prefix}${key} = ${value}\n`;
+      }
+    }
+
+    return result;
+  }
+}
+
+// 导出单例实例
+export const configManager = new ConfigManager();

package/src/core/evaluator/base-rule.ts

@@ -0,0 +1,90 @@
+import type { Trace, EvaluationResult } from '../../types/index.js';
+
+/**
+ * 评估规则基类
+ */
+export abstract class BaseRule {
+  protected name: string;
+  protected description: string;
+
+  constructor(name: string, description: string) {
+    this.name = name;
+    this.description = description;
+  }
+
+  /**
+   * 评估 traces，返回评估结果
+   */
+  abstract evaluate(traces: Trace[]): EvaluationResult | null;
+
+  /**
+   * 获取规则名称
+   */
+  getName(): string {
+    return this.name;
+  }
+
+  /**
+   * 获取规则描述
+   */
+  getDescription(): string {
+    return this.description;
+  }
+
+  /**
+   * 提取唯一的 session IDs
+   */
+  protected extractSessionIds(traces: Trace[]): string[] {
+    const sessionIds = new Set(traces.map((t) => t.session_id));
+    return Array.from(sessionIds);
+  }
+
+  /**
+   * 按事件类型过滤 traces
+   */
+  protected filterByEventType(traces: Trace[], eventType: string): Trace[] {
+    return traces.filter((t) => t.event_type === eventType);
+  }
+
+  /**
+   * 按状态过滤 traces
+   */
+  protected filterByStatus(traces: Trace[], status: string): Trace[] {
+    return traces.filter((t) => t.status === status);
+  }
+
+  /**
+   * 获取失败的 traces
+   */
+  protected getFailedTraces(traces: Trace[]): Trace[] {
+    return this.filterByStatus(traces, 'failure');
+  }
+
+  /**
+   * 获取重试的 traces
+   */
+  protected getRetryTraces(traces: Trace[]): Trace[] {
+    return this.filterByEventType(traces, 'retry');
+  }
+
+  /**
+   * 获取文件变化的 traces
+   */
+  protected getFileChangeTraces(traces: Trace[]): Trace[] {
+    return this.filterByEventType(traces, 'file_change');
+  }
+
+  /**
+   * 计算置信度
+   */
+  protected calculateConfidence(
+    signalCount: number,
+    sessionCount: number,
+    minSignals: number = 3,
+    minSessions: number = 2
+  ): number {
+    const signalScore = Math.min(signalCount / minSignals, 1) * 0.6;
+    const sessionScore = Math.min(sessionCount / minSessions, 1) * 0.4;
+    return Math.min(signalScore + sessionScore, 1);
+  }
+}

package/src/core/evaluator/index.ts

@@ -0,0 +1,86 @@
+import { createChildLogger } from '../../utils/logger.js';
+import { configManager } from '../../config/index.js';
+import { BaseRule } from './base-rule.js';
+import { RepeatedManualFixRule } from './rules/repeated-manual-fix.js';
+import { RepeatedDriftRule } from './rules/repeated-drift.js';
+import type { Trace, EvaluationResult } from '../../types/index.js';
+
+const logger = createChildLogger('evaluator');
+
+/**
+ * Evaluator
+ * 负责评估 traces 并判断是否需要优化
+ */
+export class Evaluator {
+  private rules: BaseRule[] = [];
+  private minConfidence: number;
+
+  constructor() {
+    this.minConfidence = configManager.getEvaluatorConfig().min_confidence;
+    this.registerDefaultRules();
+  }
+
+  /**
+   * 注册默认规则
+   */
+  private registerDefaultRules(): void {
+    this.rules.push(new RepeatedManualFixRule());
+    this.rules.push(new RepeatedDriftRule());
+    logger.info('Default evaluation rules registered');
+  }
+
+  /**
+   * 注册自定义规则
+   */
+  registerRule(rule: BaseRule): void {
+    this.rules.push(rule);
+    logger.info(`Rule registered: ${rule.getName()}`);
+  }
+
+  /**
+   * 评估 traces
+   */
+  evaluate(traces: Trace[]): EvaluationResult | null {
+    if (traces.length === 0) {
+      return null;
+    }
+
+    logger.debug(`Evaluating ${traces.length} traces with ${this.rules.length} rules`);
+
+    // 运行所有规则
+    for (const rule of this.rules) {
+      try {
+        const result = rule.evaluate(traces);
+
+        if (result && result.confidence >= this.minConfidence) {
+          logger.info(`Rule "${rule.getName()}" triggered`, {
+            change_type: result.change_type,
+            confidence: result.confidence,
+          });
+          return result;
+        }
+      } catch (error) {
+        logger.warn(`Rule "${rule.getName()}" evaluation failed`, { error });
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * 获取所有规则
+   */
+  getRules(): BaseRule[] {
+    return [...this.rules];
+  }
+
+  /**
+   * 设置最小置信度
+   */
+  setMinConfidence(confidence: number): void {
+    this.minConfidence = confidence;
+  }
+}
+
+// 导出单例实例
+export const evaluator = new Evaluator();

package/src/core/evaluator/rules/repeated-drift.ts

@@ -0,0 +1,109 @@
+import { BaseRule } from '../base-rule.js';
+import type { Trace, EvaluationResult } from '../../../types/index.js';
+
+/**
+ * Repeated Drift 规则
+ * 检测 skill 被命中但执行反复绕过某一段
+ */
+export class RepeatedDriftRule extends BaseRule {
+  constructor() {
+    super(
+      'repeated-drift',
+      'Detects when skill is hit but execution repeatedly bypasses certain sections'
+    );
+  }
+
+  evaluate(traces: Trace[]): EvaluationResult | null {
+    // 查找工具调用
+    const toolCalls = this.filterByEventType(traces, 'tool_call');
+
+    if (toolCalls.length === 0) {
+      return null;
+    }
+
+    // 找出被跳过的工具或步骤
+    const skippedTools = this.findSkippedTools(traces);
+
+    if (skippedTools.length === 0) {
+      return null;
+    }
+
+    // 统计跳过次数
+    const skipCount = this.countSkips(traces, skippedTools);
+
+    if (skipCount < 3) {
+      return null;
+    }
+
+    const sessionIds = this.extractSessionIds(traces);
+    const confidence = this.calculateConfidence(skipCount, sessionIds.length);
+
+    if (confidence < 0.7) {
+      return null;
+    }
+
+    return {
+      should_patch: true,
+      change_type: 'prune_noise',
+      reason: `Skill section "${skippedTools[0]}" was skipped ${skipCount} times across ${sessionIds.length} sessions`,
+      source_sessions: sessionIds,
+      confidence,
+    };
+  }
+
+  /**
+   * 找出被跳过的工具
+   */
+  private findSkippedTools(traces: Trace[]): string[] {
+    const skipped: string[] = [];
+
+    // 查找在工具调用后没有结果的情况
+    for (const trace of traces) {
+      if (trace.event_type === 'tool_call' && trace.tool_name) {
+        // 查找后续的工具结果
+        const subsequentResults = traces.filter(
+          (t) =>
+            t.event_type === 'tool_result' &&
+            t.tool_name === trace.tool_name &&
+            new Date(t.timestamp) > new Date(trace.timestamp) &&
+            new Date(t.timestamp).getTime() - new Date(trace.timestamp).getTime() < 5000
+        );
+
+        if (subsequentResults.length === 0) {
+          // 没有找到对应的结果，可能是被跳过了
+          if (!skipped.includes(trace.tool_name)) {
+            skipped.push(trace.tool_name);
+          }
+        }
+      }
+    }
+
+    return skipped;
+  }
+
+  /**
+   * 统计跳过次数
+   */
+  private countSkips(traces: Trace[], skippedTools: string[]): number {
+    let count = 0;
+
+    for (const trace of traces) {
+      if (trace.event_type === 'tool_call' && skippedTools.includes(trace.tool_name ?? '')) {
+        // 检查是否有对应的工具结果
+        const hasResult = traces.some(
+          (t) =>
+            t.event_type === 'tool_result' &&
+            t.tool_name === trace.tool_name &&
+            new Date(t.timestamp) > new Date(trace.timestamp) &&
+            new Date(t.timestamp).getTime() - new Date(trace.timestamp).getTime() < 5000
+        );
+
+        if (!hasResult) {
+          count++;
+        }
+      }
+    }
+
+    return count;
+  }
+}

package/src/core/evaluator/rules/repeated-manual-fix.ts

@@ -0,0 +1,129 @@
+import { BaseRule } from '../base-rule.js';
+import type { Trace, EvaluationResult } from '../../../types/index.js';
+
+/**
+ * Repeated Manual Fix 规则
+ * 检测用户是否在同类任务中反复手动补充相同步骤
+ */
+export class RepeatedManualFixRule extends BaseRule {
+  constructor() {
+    super(
+      'repeated-manual-fix',
+      'Detects when users repeatedly manually supplement the same steps after agent output'
+    );
+  }
+
+  evaluate(traces: Trace[]): EvaluationResult | null {
+    // 查找用户在助手输出后的输入
+    const assistantOutputs = this.filterByEventType(traces, 'assistant_output');
+    const userInputs = this.filterByEventType(traces, 'user_input');
+
+    if (assistantOutputs.length === 0 || userInputs.length === 0) {
+      return null;
+    }
+
+    // 分析用户输入中是否有重复的模式
+    const patterns = this.extractPatterns(userInputs);
+
+    // 找出出现频率最高的模式
+    const frequentPatterns = this.findFrequentPatterns(patterns, 3);
+
+    if (frequentPatterns.length === 0) {
+      return null;
+    }
+
+    // 检查这些模式是否出现在助手输出之后
+    const signals = this.countPostAssistantSignals(assistantOutputs, userInputs, frequentPatterns);
+
+    if (signals.count < 3) {
+      return null;
+    }
+
+    const sessionIds = this.extractSessionIds(traces);
+    const confidence = this.calculateConfidence(signals.count, sessionIds.length);
+
+    if (confidence < 0.7) {
+      return null;
+    }
+
+    return {
+      should_patch: true,
+      change_type: 'add_fallback',
+      reason: `User manually supplemented "${signals.pattern}" in ${signals.count} sessions after agent output`,
+      source_sessions: sessionIds,
+      confidence,
+    };
+  }
+
+  /**
+   * 提取用户输入的模式
+   */
+  private extractPatterns(userInputs: Trace[]): Map<string, number> {
+    const patterns = new Map<string, number>();
+
+    for (const input of userInputs) {
+      if (!input.user_input) continue;
+
+      // 简单的模式提取：取前 50 个字符作为模式
+      const pattern = input.user_input.substring(0, 50).toLowerCase().trim();
+      if (pattern.length > 10) {
+        patterns.set(pattern, (patterns.get(pattern) ?? 0) + 1);
+      }
+    }
+
+    return patterns;
+  }
+
+  /**
+   * 找出频繁出现的模式
+   */
+  private findFrequentPatterns(patterns: Map<string, number>, minCount: number): string[] {
+    const result: string[] = [];
+
+    for (const [pattern, count] of patterns.entries()) {
+      if (count >= minCount) {
+        result.push(pattern);
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * 统计助手输出后出现的信号
+   */
+  private countPostAssistantSignals(
+    assistantOutputs: Trace[],
+    userInputs: Trace[],
+    patterns: string[]
+  ): { count: number; pattern: string } {
+    let maxCount = 0;
+    let bestPattern = '';
+
+    for (const pattern of patterns) {
+      let count = 0;
+
+      for (const output of assistantOutputs) {
+        // 查找在助手输出后的用户输入
+        const subsequentInputs = userInputs.filter(
+          (input) =>
+            new Date(input.timestamp) > new Date(output.timestamp) &&
+            new Date(input.timestamp).getTime() - new Date(output.timestamp).getTime() < 60000 // 1 分钟内
+        );
+
+        for (const input of subsequentInputs) {
+          if (input.user_input?.toLowerCase().includes(pattern)) {
+            count++;
+          }
+        }
+      }
+
+      if (count > maxCount) {
+        maxCount = count;
+        bestPattern = pattern;
+      }
+    }
+
+    return { count: maxCount, pattern: bestPattern };
+  }
+}