evo-skills 0.1.0

package/src/core/origin-registry/index.ts

@@ -0,0 +1,264 @@
+import { readdirSync, existsSync } from 'node:fs';
+import { join, basename } from 'node:path';
+import { createChildLogger } from '../../utils/logger.js';
+import { hashFile } from '../../utils/hash.js';
+import { expandHome, isDirectory, isFile } from '../../utils/path.js';
+import { configManager } from '../../config/index.js';
+import type { OriginSkill } from '../../types/index.js';
+
+const logger = createChildLogger('origin-registry');
+
+/**
+ * Origin Skill 注册表
+ * 负责扫描和管理用户本机已安装的 skills
+ */
+export class OriginRegistry {
+  private skills: Map<string, OriginSkill> = new Map();
+  private lastScanTime: number = 0;
+
+  /**
+   * 扫描所有配置的 skill 目录
+   */
+  async scan(): Promise<OriginSkill[]> {
+    const paths = configManager.getOriginPaths();
+    const allSkills: OriginSkill[] = [];
+
+    for (const skillPath of paths) {
+      const expandedPath = expandHome(skillPath);
+      if (!existsSync(expandedPath)) {
+        logger.debug(`Skill path not found: ${expandedPath}`);
+        continue;
+      }
+
+      try {
+        const skills = await this.scanDirectory(expandedPath);
+        allSkills.push(...skills);
+      } catch (error) {
+        logger.warn(`Failed to scan directory: ${expandedPath}`, { error });
+      }
+    }
+
+    // 更新内部缓存
+    this.skills.clear();
+    for (const skill of allSkills) {
+      this.skills.set(skill.skill_id, skill);
+    }
+
+    this.lastScanTime = Date.now();
+    logger.info(`Scanned ${allSkills.length} origin skills`);
+
+    return allSkills;
+  }
+
+  /**
+   * 扫描单个目录
+   */
+  private async scanDirectory(dirPath: string): Promise<OriginSkill[]> {
+    const skills: OriginSkill[] = [];
+
+    if (!isDirectory(dirPath)) {
+      return skills;
+    }
+
+    const entries = readdirSync(dirPath);
+
+    for (const entry of entries) {
+      const fullPath = join(dirPath, entry);
+
+      // 检查是否是目录（skill 通常是目录形式）
+      if (isDirectory(fullPath)) {
+        const skill = this.readSkillFromDirectory(fullPath, entry);
+        if (skill) {
+          skills.push(skill);
+        }
+      }
+      // 或者是单个 .md 文件
+      else if (entry.endsWith('.md') && isFile(fullPath)) {
+        const skillId = basename(entry, '.md');
+        const skill = this.readSkillFromFile(fullPath, skillId);
+        if (skill) {
+          skills.push(skill);
+        }
+      }
+    }
+
+    return skills;
+  }
+
+  /**
+   * 从目录读取 skill
+   */
+  private readSkillFromDirectory(dirPath: string, skillId: string): OriginSkill | null {
+    try {
+      // 查找主要的 skill 文件（通常是 current.md 或 skill.md）
+      const possibleFiles = ['current.md', 'skill.md', `${skillId}.md`];
+      let mainFile: string | null = null;
+
+      for (const filename of possibleFiles) {
+        const filePath = join(dirPath, filename);
+        if (isFile(filePath)) {
+          mainFile = filePath;
+          break;
+        }
+      }
+
+      if (!mainFile) {
+        logger.debug(`No skill file found in directory: ${dirPath}`);
+        return null;
+      }
+
+      const version = hashFile(mainFile);
+      const now = new Date().toISOString();
+
+      return {
+        skill_id: skillId,
+        origin_path: dirPath,
+        origin_version: version,
+        source: this.detectSource(dirPath),
+        installed_at: now,
+        last_seen_at: now,
+      };
+    } catch (error) {
+      logger.warn(`Failed to read skill from directory: ${dirPath}`, { error });
+      return null;
+    }
+  }
+
+  /**
+   * 从文件读取 skill
+   */
+  private readSkillFromFile(filePath: string, skillId: string): OriginSkill | null {
+    try {
+      const version = hashFile(filePath);
+      const now = new Date().toISOString();
+
+      return {
+        skill_id: skillId,
+        origin_path: filePath,
+        origin_version: version,
+        source: this.detectSource(filePath),
+        installed_at: now,
+        last_seen_at: now,
+      };
+    } catch (error) {
+      logger.warn(`Failed to read skill from file: ${filePath}`, { error });
+      return null;
+    }
+  }
+
+  /**
+   * 检测 skill 来源
+   */
+  private detectSource(path: string): 'local' | 'marketplace' | 'git' {
+    if (path.includes('.git') || path.includes('github')) {
+      return 'git';
+    }
+    if (path.includes('marketplace') || path.includes('registry')) {
+      return 'marketplace';
+    }
+    return 'local';
+  }
+
+  /**
+   * 获取指定 skill
+   */
+  get(skillId: string): OriginSkill | null {
+    return this.skills.get(skillId) ?? null;
+  }
+
+  /**
+   * 获取所有 skills
+   */
+  list(): OriginSkill[] {
+    return Array.from(this.skills.values());
+  }
+
+  /**
+   * 检查 skill 是否有更新
+   */
+  checkUpdate(skillId: string): boolean {
+    const skill = this.skills.get(skillId);
+    if (!skill) {
+      return false;
+    }
+
+    try {
+      const currentVersion = hashFile(skill.origin_path);
+      return currentVersion !== skill.origin_version;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * 读取 origin skill 内容
+   */
+  readContent(skillId: string): string | null {
+    const skill = this.skills.get(skillId);
+    if (!skill) {
+      return null;
+    }
+
+    try {
+      const { readFileSync } = require('node:fs');
+
+      // 如果是目录，查找主文件
+      if (isDirectory(skill.origin_path)) {
+        const possibleFiles = ['current.md', 'skill.md', `${skillId}.md`];
+        for (const filename of possibleFiles) {
+          const filePath = join(skill.origin_path, filename);
+          if (isFile(filePath)) {
+            return readFileSync(filePath, 'utf-8');
+          }
+        }
+      }
+      // 如果是文件，直接读取
+      else if (isFile(skill.origin_path)) {
+        return readFileSync(skill.origin_path, 'utf-8');
+      }
+
+      return null;
+    } catch (error) {
+      logger.warn(`Failed to read skill content: ${skillId}`, { error });
+      return null;
+    }
+  }
+
+  /**
+   * 刷新单个 skill 的版本信息
+   */
+  refreshSkill(skillId: string): OriginSkill | null {
+    const skill = this.skills.get(skillId);
+    if (!skill) {
+      return null;
+    }
+
+    try {
+      const newVersion = hashFile(skill.origin_path);
+      skill.origin_version = newVersion;
+      skill.last_seen_at = new Date().toISOString();
+      return skill;
+    } catch (error) {
+      logger.warn(`Failed to refresh skill: ${skillId}`, { error });
+      return null;
+    }
+  }
+
+  /**
+   * 获取上次扫描时间
+   */
+  getLastScanTime(): number {
+    return this.lastScanTime;
+  }
+
+  /**
+   * 检查是否需要重新扫描
+   */
+  needsRescan(): boolean {
+    const scanInterval = 3600 * 1000; // 1 小时
+    return Date.now() - this.lastScanTime > scanInterval;
+  }
+}
+
+// 导出单例实例
+export const originRegistry = new OriginRegistry();

package/src/core/patch-generator/base-strategy.ts

@@ -0,0 +1,67 @@
+import type { PatchResult, ChangeType } from '../../types/index.js';
+
+/**
+ * Patch 策略基类
+ */
+export abstract class BaseStrategy {
+  protected name: string;
+  protected description: string;
+  protected changeType: ChangeType;
+
+  constructor(name: string, description: string, changeType: ChangeType) {
+    this.name = name;
+    this.description = description;
+    this.changeType = changeType;
+  }
+
+  /**
+   * 生成 patch
+   */
+  abstract generate(currentContent: string, context: Record<string, unknown>): PatchResult;
+
+  /**
+   * 获取策略名称
+   */
+  getName(): string {
+    return this.name;
+  }
+
+  /**
+   * 获取策略描述
+   */
+  getDescription(): string {
+    return this.description;
+  }
+
+  /**
+   * 获取变更类型
+   */
+  getChangeType(): ChangeType {
+    return this.changeType;
+  }
+
+  /**
+   * 创建成功的 PatchResult
+   */
+  protected createSuccessResult(patch: string, newContent: string): PatchResult {
+    return {
+      success: true,
+      patch,
+      newContent,
+      changeType: this.changeType,
+    };
+  }
+
+  /**
+   * 创建失败的 PatchResult
+   */
+  protected createFailureResult(error: string): PatchResult {
+    return {
+      success: false,
+      patch: '',
+      newContent: '',
+      changeType: this.changeType,
+      error,
+    };
+  }
+}

package/src/core/patch-generator/index.ts

@@ -0,0 +1,118 @@
+import { createChildLogger } from '../../utils/logger.js';
+import { configManager } from '../../config/index.js';
+import { BaseStrategy } from './base-strategy.js';
+import { AddFallbackStrategy } from './strategies/add-fallback.js';
+import { PruneNoiseStrategy } from './strategies/prune-noise.js';
+import type { PatchResult, ChangeType } from '../../types/index.js';
+
+const logger = createChildLogger('patch-generator');
+
+/**
+ * Patch Generator
+ * 负责生成具体的 patch
+ */
+export class PatchGenerator {
+  private strategies: Map<ChangeType, BaseStrategy> = new Map();
+
+  constructor() {
+    this.registerDefaultStrategies();
+  }
+
+  /**
+   * 注册默认策略
+   */
+  private registerDefaultStrategies(): void {
+    this.registerStrategy(new AddFallbackStrategy());
+    this.registerStrategy(new PruneNoiseStrategy());
+    logger.info('Default patch strategies registered');
+  }
+
+  /**
+   * 注册策略
+   */
+  registerStrategy(strategy: BaseStrategy): void {
+    this.strategies.set(strategy.getChangeType(), strategy);
+    logger.info(`Strategy registered: ${strategy.getName()}`);
+  }
+
+  /**
+   * 生成 patch
+   */
+  generate(
+    changeType: ChangeType,
+    currentContent: string,
+    context: Record<string, unknown>
+  ): PatchResult {
+    const strategy = this.strategies.get(changeType);
+
+    if (!strategy) {
+      logger.warn(`No strategy found for change type: ${changeType}`);
+      return {
+        success: false,
+        patch: '',
+        newContent: '',
+        changeType,
+        error: `No strategy found for change type: ${changeType}`,
+      };
+    }
+
+    // 检查是否允许此类型的 patch
+    const allowedTypes = configManager.getPatchConfig().allowed_types;
+    if (!allowedTypes.includes(changeType)) {
+      logger.warn(`Change type ${changeType} is not allowed`);
+      return {
+        success: false,
+        patch: '',
+        newContent: '',
+        changeType,
+        error: `Change type ${changeType} is not allowed`,
+      };
+    }
+
+    logger.debug(`Generating patch with strategy: ${strategy.getName()}`);
+
+    try {
+      const result = strategy.generate(currentContent, context);
+
+      if (result.success) {
+        logger.info(`Patch generated successfully`, {
+          strategy: strategy.getName(),
+          changeType,
+        });
+      } else {
+        logger.warn(`Patch generation failed`, {
+          strategy: strategy.getName(),
+          error: result.error,
+        });
+      }
+
+      return result;
+    } catch (error) {
+      logger.error(`Strategy execution failed`, { error });
+      return {
+        success: false,
+        patch: '',
+        newContent: '',
+        changeType,
+        error: `Strategy execution failed: ${error}`,
+      };
+    }
+  }
+
+  /**
+   * 获取所有策略
+   */
+  getStrategies(): BaseStrategy[] {
+    return Array.from(this.strategies.values());
+  }
+
+  /**
+   * 检查是否支持某个变更类型
+   */
+  supportsChangeType(changeType: ChangeType): boolean {
+    return this.strategies.has(changeType);
+  }
+}
+
+// 导出单例实例
+export const patchGenerator = new PatchGenerator();

package/src/core/patch-generator/strategies/add-fallback.ts

@@ -0,0 +1,69 @@
+import { BaseStrategy } from '../base-strategy.js';
+import { createUnifiedDiff } from '../../../utils/diff.js';
+import type { PatchResult } from '../../../types/index.js';
+
+/**
+ * Add Fallback 策略
+ * 在相关步骤后添加 fallback 说明
+ */
+export class AddFallbackStrategy extends BaseStrategy {
+  constructor() {
+    super(
+      'add-fallback',
+      'Add fallback instructions after relevant steps',
+      'add_fallback'
+    );
+  }
+
+  generate(currentContent: string, context: Record<string, unknown>): PatchResult {
+    try {
+      const pattern = context.pattern as string;
+      const reason = context.reason as string;
+
+      if (!pattern) {
+        return this.createFailureResult('Pattern not provided');
+      }
+
+      // 查找插入点（在文件末尾或特定 section 后）
+      const lines = currentContent.split('\n');
+      let insertIndex = lines.length;
+
+      // 尝试找到 "## Fallback" 或类似的 section
+      for (let i = 0; i < lines.length; i++) {
+        if (lines[i]?.toLowerCase().includes('fallback') ||
+            lines[i]?.toLowerCase().includes('error handling')) {
+          // 在这个 section 后插入
+          insertIndex = i + 1;
+          while (insertIndex < lines.length && lines[insertIndex]?.startsWith('-')) {
+            insertIndex++;
+          }
+          break;
+        }
+      }
+
+      // 创建新的 fallback 内容
+      const fallbackContent = [
+        '',
+        `## Additional Fallback`,
+        '',
+        `- If the agent output does not include "${pattern}", manually add it`,
+        `- Reason: ${reason}`,
+        '',
+      ];
+
+      // 插入内容
+      const newLines = [
+        ...lines.slice(0, insertIndex),
+        ...fallbackContent,
+        ...lines.slice(insertIndex),
+      ];
+
+      const newContent = newLines.join('\n');
+      const patch = createUnifiedDiff('skill.md', currentContent, newContent);
+
+      return this.createSuccessResult(patch, newContent);
+    } catch (error) {
+      return this.createFailureResult(`Failed to generate patch: ${error}`);
+    }
+  }
+}

package/src/core/patch-generator/strategies/prune-noise.ts

@@ -0,0 +1,65 @@
+import { BaseStrategy } from '../base-strategy.js';
+import { createUnifiedDiff } from '../../../utils/diff.js';
+import type { PatchResult } from '../../../types/index.js';
+
+/**
+ * Prune Noise 策略
+ * 删除被忽略的冗余说明
+ */
+export class PruneNoiseStrategy extends BaseStrategy {
+  constructor() {
+    super(
+      'prune-noise',
+      'Remove redundant or ignored instructions',
+      'prune_noise'
+    );
+  }
+
+  generate(currentContent: string, context: Record<string, unknown>): PatchResult {
+    try {
+      const section = context.section as string;
+
+      if (!section) {
+        return this.createFailureResult('Section not provided');
+      }
+
+      // 查找要删除的 section
+      const lines = currentContent.split('\n');
+      const sectionIndex = lines.findIndex((line) =>
+        line.toLowerCase().includes(section.toLowerCase())
+      );
+
+      if (sectionIndex === -1) {
+        return this.createFailureResult(`Section "${section}" not found`);
+      }
+
+      // 找到 section 的结束位置
+      let endIndex = sectionIndex + 1;
+      const sectionLevel = lines[sectionIndex]?.match(/^(#{1,6})/)?.[1]?.length ?? 0;
+
+      while (endIndex < lines.length) {
+        const line = lines[endIndex];
+        const match = line?.match(/^(#{1,6})\s/);
+
+        if (match && match[1].length <= sectionLevel) {
+          break;
+        }
+
+        endIndex++;
+      }
+
+      // 删除 section
+      const newLines = [
+        ...lines.slice(0, sectionIndex),
+        ...lines.slice(endIndex),
+      ];
+
+      const newContent = newLines.join('\n');
+      const patch = createUnifiedDiff('skill.md', currentContent, newContent);
+
+      return this.createSuccessResult(patch, newContent);
+    } catch (error) {
+      return this.createFailureResult(`Failed to generate patch: ${error}`);
+    }
+  }
+}