evo-skills 0.1.0

package/src/cli/commands/diff.ts

@@ -0,0 +1,158 @@
+import { Command } from 'commander';
+import { join } from 'node:path';
+import { existsSync, readFileSync } from 'node:fs';
+import { createShadowRegistry } from '../../core/shadow-registry/index.js';
+import { createJournalManager } from '../../core/journal/index.js';
+import { originRegistry } from '../../core/origin-registry/index.js';
+import { createUnifiedDiff } from '../../utils/diff.js';
+
+/**
+ * Diff 命令
+ * 查看当前内容与 origin 的 diff
+ */
+export function createDiffCommand(): Command {
+  const diff = new Command('diff');
+
+  diff
+    .description('Show diff between shadow skill and origin')
+    .argument('<skill>', 'Skill ID to show diff for')
+    .option('-r, --revision <number>', 'Compare with specific revision')
+    .option('-o, --origin', 'Compare with origin skill')
+    .option('-p, --project <path>', 'Project root path', process.cwd())
+    .action(async (skillId: string, options) => {
+      try {
+        const projectRoot = options.project;
+
+        // 检查 .sea 目录是否存在
+        const seaDir = join(projectRoot, '.sea');
+        if (!existsSync(seaDir)) {
+          console.error('Error: .sea directory not found. Is this a SEA project?');
+          process.exit(1);
+        }
+
+        // 初始化组件
+        const shadowRegistry = createShadowRegistry(projectRoot);
+        const journalManager = createJournalManager(projectRoot);
+
+        await shadowRegistry.init();
+        await journalManager.init();
+
+        // 检查 shadow 是否存在
+        const shadow = await shadowRegistry.get(skillId);
+        if (!shadow) {
+          console.error(`Error: Shadow skill "${skillId}" not found`);
+          process.exit(1);
+        }
+
+        // 读取当前内容
+        const currentContent = await shadowRegistry.readContent(skillId);
+        if (!currentContent) {
+          console.error(`Error: Cannot read shadow content for "${skillId}"`);
+          process.exit(1);
+        }
+
+        const shadowId = `${skillId}@${projectRoot}`;
+
+        if (options.origin) {
+          // 与 origin 比较
+          await originRegistry.scan();
+          const origin = originRegistry.get(skillId);
+
+          if (!origin) {
+            console.error(`Error: Origin skill "${skillId}" not found`);
+            process.exit(1);
+          }
+
+          const originContent = originRegistry.readContent(skillId);
+          if (!originContent) {
+            console.error(`Error: Cannot read origin content for "${skillId}"`);
+            process.exit(1);
+          }
+
+          const diffOutput = createUnifiedDiff(
+            `origin/${skillId}`,
+            originContent,
+            currentContent,
+            'origin',
+            'shadow'
+          );
+
+          if (diffOutput) {
+            console.log(`Diff between origin and shadow for "${skillId}":\n`);
+            console.log(diffOutput);
+          } else {
+            console.log(`No differences found between origin and shadow for "${skillId}"`);
+          }
+        } else if (options.revision) {
+          // 与指定 revision 比较
+          const targetRevision = parseInt(options.revision, 10);
+          const record = await journalManager.getRecordByRevision(shadowId, targetRevision);
+
+          if (!record) {
+            console.error(`Error: Revision ${targetRevision} not found`);
+            process.exit(1);
+          }
+
+          // 从 snapshot 读取旧内容
+          const snapshots = journalManager.getSnapshots(shadowId);
+          const snapshot = snapshots.find((s) => s.revision === targetRevision);
+
+          if (!snapshot) {
+            console.error(`Error: Snapshot for revision ${targetRevision} not found`);
+            process.exit(1);
+          }
+
+          const oldContent = readFileSync(snapshot.file_path, 'utf-8');
+          const diffOutput = createUnifiedDiff(
+            `${skillId}@rev${targetRevision}`,
+            oldContent,
+            currentContent,
+            `rev${targetRevision}`,
+            'current'
+          );
+
+          if (diffOutput) {
+            console.log(`Diff between revision ${targetRevision} and current for "${skillId}":\n`);
+            console.log(diffOutput);
+          } else {
+            console.log(`No differences found between revision ${targetRevision} and current`);
+          }
+        } else {
+          // 默认显示与 origin 的 diff
+          await originRegistry.scan();
+          const origin = originRegistry.get(skillId);
+
+          if (!origin) {
+            console.log(`Origin skill "${skillId}" not found, cannot show diff`);
+          } else {
+            const originContent = originRegistry.readContent(skillId);
+            if (originContent) {
+              const diffOutput = createUnifiedDiff(
+                `origin/${skillId}`,
+                originContent,
+                currentContent,
+                'origin',
+                'shadow'
+              );
+
+              if (diffOutput) {
+                console.log(`Diff between origin and shadow for "${skillId}":\n`);
+                console.log(diffOutput);
+              } else {
+                console.log(`No differences found between origin and shadow for "${skillId}"`);
+              }
+            }
+          }
+        }
+
+        // 关闭
+        shadowRegistry.close();
+        journalManager.close();
+      } catch (error) {
+        console.error(`Error: ${error}`);
+        process.exit(1);
+      }
+    });
+
+  return diff;
+}

package/src/cli/commands/freeze.ts

@@ -0,0 +1,108 @@
+import { Command } from 'commander';
+import { join } from 'node:path';
+import { existsSync } from 'node:fs';
+import { createShadowRegistry } from '../../core/shadow-registry/index.js';
+
+/**
+ * Freeze 命令
+ * 暂停某个 skill 的自动优化
+ */
+export function createFreezeCommand(): Command {
+  const freeze = new Command('freeze');
+
+  freeze
+    .description('Pause automatic optimization for a shadow skill')
+    .argument('<skill>', 'Skill ID to freeze')
+    .option('-p, --project <path>', 'Project root path', process.cwd())
+    .action(async (skillId: string, options) => {
+      try {
+        const projectRoot = options.project;
+
+        // 检查 .sea 目录是否存在
+        const seaDir = join(projectRoot, '.sea');
+        if (!existsSync(seaDir)) {
+          console.error('Error: .sea directory not found. Is this a SEA project?');
+          process.exit(1);
+        }
+
+        // 初始化组件
+        const shadowRegistry = createShadowRegistry(projectRoot);
+        await shadowRegistry.init();
+
+        // 检查 shadow 是否存在
+        const shadow = await shadowRegistry.get(skillId);
+        if (!shadow) {
+          console.error(`Error: Shadow skill "${skillId}" not found`);
+          process.exit(1);
+        }
+
+        // 更新状态为 frozen
+        const shadowId = `${skillId}@${projectRoot}`;
+        await shadowRegistry.updateStatus(shadowId, 'frozen');
+
+        console.log(`✅ Shadow skill "${skillId}" has been frozen`);
+        console.log('Automatic optimization is now paused for this skill');
+        console.log('\nTo unfreeze, use:');
+        console.log(`  sea skills unfreeze ${skillId}`);
+
+        // 关闭
+        shadowRegistry.close();
+      } catch (error) {
+        console.error(`Error: ${error}`);
+        process.exit(1);
+      }
+    });
+
+  return freeze;
+}
+
+/**
+ * Unfreeze 命令
+ * 恢复某个 skill 的自动优化
+ */
+export function createUnfreezeCommand(): Command {
+  const unfreeze = new Command('unfreeze');
+
+  unfreeze
+    .description('Resume automatic optimization for a shadow skill')
+    .argument('<skill>', 'Skill ID to unfreeze')
+    .option('-p, --project <path>', 'Project root path', process.cwd())
+    .action(async (skillId: string, options) => {
+      try {
+        const projectRoot = options.project;
+
+        // 检查 .sea 目录是否存在
+        const seaDir = join(projectRoot, '.sea');
+        if (!existsSync(seaDir)) {
+          console.error('Error: .sea directory not found. Is this a SEA project?');
+          process.exit(1);
+        }
+
+        // 初始化组件
+        const shadowRegistry = createShadowRegistry(projectRoot);
+        await shadowRegistry.init();
+
+        // 检查 shadow 是否存在
+        const shadow = await shadowRegistry.get(skillId);
+        if (!shadow) {
+          console.error(`Error: Shadow skill "${skillId}" not found`);
+          process.exit(1);
+        }
+
+        // 更新状态为 active
+        const shadowId = `${skillId}@${projectRoot}`;
+        await shadowRegistry.updateStatus(shadowId, 'active');
+
+        console.log(`✅ Shadow skill "${skillId}" has been unfrozen`);
+        console.log('Automatic optimization is now resumed for this skill');
+
+        // 关闭
+        shadowRegistry.close();
+      } catch (error) {
+        console.error(`Error: ${error}`);
+        process.exit(1);
+      }
+    });
+
+  return unfreeze;
+}

package/src/cli/commands/log.ts

@@ -0,0 +1,87 @@
+import { Command } from 'commander';
+import { join } from 'node:path';
+import { existsSync } from 'node:fs';
+import { createShadowRegistry } from '../../core/shadow-registry/index.js';
+import { createJournalManager } from '../../core/journal/index.js';
+
+/**
+ * Log 命令
+ * 查看某个 skill 的演化日志
+ */
+export function createLogCommand(): Command {
+  const log = new Command('log');
+
+  log
+    .description('Show evolution log for a shadow skill')
+    .argument('<skill>', 'Skill ID to show log for')
+    .option('-n, --limit <number>', 'Number of records to show', '20')
+    .option('-f, --follow', 'Follow log output (like tail -f)')
+    .option('-t, --type <type>', 'Filter by change type')
+    .option('-p, --project <path>', 'Project root path', process.cwd())
+    .action(async (skillId: string, options) => {
+      try {
+        const projectRoot = options.project;
+
+        // 检查 .sea 目录是否存在
+        const seaDir = join(projectRoot, '.sea');
+        if (!existsSync(seaDir)) {
+          console.error('Error: .sea directory not found. Is this a SEA project?');
+          process.exit(1);
+        }
+
+        // 初始化组件
+        const shadowRegistry = createShadowRegistry(projectRoot);
+        const journalManager = createJournalManager(projectRoot);
+
+        await shadowRegistry.init();
+        await journalManager.init();
+
+        // 检查 shadow 是否存在
+        const shadow = await shadowRegistry.get(skillId);
+        if (!shadow) {
+          console.error(`Error: Shadow skill "${skillId}" not found`);
+          process.exit(1);
+        }
+
+        const shadowId = `${skillId}@${projectRoot}`;
+        const limit = parseInt(options.limit, 10);
+
+        // 获取 journal 记录
+        const records = await journalManager.getJournalRecords(shadowId, {
+          limit,
+          changeType: options.type as any,
+        });
+
+        if (records.length === 0) {
+          console.log(`No evolution records found for "${skillId}"`);
+        } else {
+          console.log(`Evolution log for "${skillId}":\n`);
+
+          for (const record of records) {
+            const date = new Date(record.timestamp).toLocaleString();
+            const changeType = record.change_type.toUpperCase();
+            const appliedBy = record.applied_by === 'auto' ? '🤖' : '👤';
+
+            console.log(`${appliedBy} rev_${String(record.revision).padStart(4, '0')} - ${date}`);
+            console.log(`   Type: ${changeType}`);
+            console.log(`   Reason: ${record.reason}`);
+            console.log(`   Sessions: ${record.source_sessions.length}`);
+            console.log('');
+          }
+
+          console.log(`Showing ${records.length} of ${limit} most recent records`);
+          console.log('\nFor more details, use:');
+          console.log(`  sea skills diff ${skillId} --from <revision>`);
+        }
+
+        // 关闭
+        shadowRegistry.close();
+        journalManager.close();
+      } catch (error) {
+        console.error(`Error: ${error}`);
+        process.exit(1);
+      }
+    });
+
+  return log;
+}

package/src/cli/commands/rollback.ts

@@ -0,0 +1,99 @@
+import { Command } from 'commander';
+import { join } from 'node:path';
+import { existsSync } from 'node:fs';
+import { createShadowRegistry } from '../../core/shadow-registry/index.js';
+import { createJournalManager } from '../../core/journal/index.js';
+
+/**
+ * Rollback 命令
+ * 回滚 shadow skill 到指定版本
+ */
+export function createRollbackCommand(): Command {
+  const rollback = new Command('rollback');
+
+  rollback
+    .description('Rollback a shadow skill to a previous version')
+    .argument('<skill>', 'Skill ID to rollback')
+    .option('-t, --to <revision>', 'Rollback to specific revision')
+    .option('-s, --snapshot', 'Rollback to latest snapshot')
+    .option('-i, --initial', 'Rollback to initial version (revision 0)')
+    .option('-p, --project <path>', 'Project root path', process.cwd())
+    .action(async (skillId: string, options) => {
+      try {
+        const projectRoot = options.project;
+
+        // 检查 .sea 目录是否存在
+        const seaDir = join(projectRoot, '.sea');
+        if (!existsSync(seaDir)) {
+          console.error('Error: .sea directory not found. Is this a SEA project?');
+          process.exit(1);
+        }
+
+        // 初始化组件
+        const shadowRegistry = createShadowRegistry(projectRoot);
+        const journalManager = createJournalManager(projectRoot);
+
+        await shadowRegistry.init();
+        await journalManager.init();
+
+        // 检查 shadow 是否存在
+        const shadow = await shadowRegistry.get(skillId);
+        if (!shadow) {
+          console.error(`Error: Shadow skill "${skillId}" not found`);
+          process.exit(1);
+        }
+
+        const shadowId = `${skillId}@${projectRoot}`;
+
+        // 确定回滚目标
+        if (options.initial) {
+          // 回滚到初始版本
+          console.log(`Rolling back "${skillId}" to initial version...`);
+          await journalManager.rollback(shadowId, 0);
+          console.log(`✅ Successfully rolled back to initial version`);
+        } else if (options.snapshot) {
+          // 回滚到最新 snapshot
+          console.log(`Rolling back "${skillId}" to latest snapshot...`);
+          await journalManager.rollbackToSnapshot(shadowId);
+          console.log(`✅ Successfully rolled back to latest snapshot`);
+        } else if (options.to) {
+          // 回滚到指定 revision
+          const targetRevision = parseInt(options.to, 10);
+          if (isNaN(targetRevision)) {
+            console.error('Error: Invalid revision number');
+            process.exit(1);
+          }
+
+          console.log(`Rolling back "${skillId}" to revision ${targetRevision}...`);
+          await journalManager.rollback(shadowId, targetRevision);
+          console.log(`✅ Successfully rolled back to revision ${targetRevision}`);
+        } else {
+          // 显示可用的 revisions
+          console.log(`Available snapshots for "${skillId}":\n`);
+          const snapshots = journalManager.getSnapshots(shadowId);
+
+          if (snapshots.length === 0) {
+            console.log('No snapshots available');
+          } else {
+            for (const snapshot of snapshots) {
+              console.log(`  rev_${String(snapshot.revision).padStart(4, '0')} - ${snapshot.timestamp}`);
+            }
+          }
+
+          console.log('\nUsage:');
+          console.log(`  sea skills rollback ${skillId} --to <revision>`);
+          console.log(`  sea skills rollback ${skillId} --snapshot`);
+          console.log(`  sea skills rollback ${skillId} --initial`);
+        }
+
+        // 关闭
+        shadowRegistry.close();
+        journalManager.close();
+      } catch (error) {
+        console.error(`Error: ${error}`);
+        process.exit(1);
+      }
+    });
+
+  return rollback;
+}

package/src/cli/commands/status.ts

@@ -0,0 +1,101 @@
+import { Command } from 'commander';
+import { join } from 'node:path';
+import { existsSync } from 'node:fs';
+import { createShadowRegistry } from '../../core/shadow-registry/index.js';
+import { createJournalManager } from '../../core/journal/index.js';
+
+/**
+ * Status 命令
+ * 查看当前项目 shadow skills 状态
+ */
+export function createStatusCommand(): Command {
+  const status = new Command('status');
+
+  status
+    .description('Show status of shadow skills in current project')
+    .option('-p, --project <path>', 'Project root path', process.cwd())
+    .option('-s, --skill <id>', 'Show detailed status for specific skill')
+    .action(async (options) => {
+      try {
+        const projectRoot = options.project;
+
+        // 检查 .sea 目录是否存在
+        const seaDir = join(projectRoot, '.sea');
+        if (!existsSync(seaDir)) {
+          console.error('Error: .sea directory not found. Is this a SEA project?');
+          process.exit(1);
+        }
+
+        // 初始化组件
+        const shadowRegistry = createShadowRegistry(projectRoot);
+        const journalManager = createJournalManager(projectRoot);
+
+        await shadowRegistry.init();
+        await journalManager.init();
+
+        if (options.skill) {
+          // 显示特定 skill 的详细状态
+          const shadow = await shadowRegistry.get(options.skill);
+          if (!shadow) {
+            console.error(`Error: Shadow skill "${options.skill}" not found`);
+            process.exit(1);
+          }
+
+          const shadowId = `${options.skill}@${projectRoot}`;
+          const latestRevision = await journalManager.getLatestRevision(shadowId);
+          const snapshots = journalManager.getSnapshots(shadowId);
+
+          console.log(`Shadow Skill: ${options.skill}`);
+          console.log(`Status: ${shadow.status}`);
+          console.log(`Current Revision: ${latestRevision}`);
+          console.log(`Created: ${shadow.created_at}`);
+          console.log(`Last Optimized: ${shadow.last_optimized_at || 'Never'}`);
+          console.log(`Snapshots: ${snapshots.length}`);
+
+          if (snapshots.length > 0) {
+            console.log('\nRecent Snapshots:');
+            for (const snapshot of snapshots.slice(0, 5)) {
+              console.log(`  rev_${String(snapshot.revision).padStart(4, '0')} - ${snapshot.timestamp}`);
+            }
+          }
+        } else {
+          // 列出所有 shadow skills
+          const shadows = await shadowRegistry.list();
+
+          if (shadows.length === 0) {
+            console.log('No shadow skills found in this project');
+            console.log('\nTo create a shadow skill, use:');
+            console.log('  sea skills fork <skill-id>');
+          } else {
+            console.log(`Shadow Skills in ${projectRoot}:\n`);
+            console.log('Skill ID                Status      Revision  Last Optimized');
+            console.log('─'.repeat(70));
+
+            for (const shadow of shadows) {
+              const shadowId = `${shadow.skill_id}@${projectRoot}`;
+              const latestRevision = await journalManager.getLatestRevision(shadowId);
+              const lastOptimized = shadow.last_optimized_at
+                ? new Date(shadow.last_optimized_at).toLocaleDateString()
+                : 'Never';
+
+              console.log(
+                `${shadow.skill_id.padEnd(22)} ${shadow.status.padEnd(11)} ${String(latestRevision).padEnd(9)} ${lastOptimized}`
+              );
+            }
+
+            console.log('\nFor detailed status of a specific skill:');
+            console.log('  sea skills status --skill <skill-id>');
+          }
+        }
+
+        // 关闭
+        shadowRegistry.close();
+        journalManager.close();
+      } catch (error) {
+        console.error(`Error: ${error}`);
+        process.exit(1);
+      }
+    });
+
+  return status;
+}

package/src/cli/index.ts

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import { createStatusCommand } from './commands/status.js';
+import { createRollbackCommand } from './commands/rollback.js';
+import { createLogCommand } from './commands/log.js';
+import { createDiffCommand } from './commands/diff.js';
+import { createFreezeCommand, createUnfreezeCommand } from './commands/freeze.js';
+
+const program = new Command();
+
+program
+  .name('evo')
+  .description('EVO Skills - Skill Evolution Agent')
+  .version('0.1.0');
+
+// Skills 子命令
+const skills = new Command('skills')
+  .description('Manage shadow skills');
+
+skills.addCommand(createStatusCommand());
+skills.addCommand(createRollbackCommand());
+skills.addCommand(createLogCommand());
+skills.addCommand(createDiffCommand());
+skills.addCommand(createFreezeCommand());
+skills.addCommand(createUnfreezeCommand());
+
+program.addCommand(skills);
+
+// 解析命令行参数
+program.parse();

package/src/config/defaults.ts

@@ -0,0 +1,32 @@
+import type { EVOConfig } from '../types/index.js';
+
+/**
+ * 默认配置
+ */
+export const DEFAULT_CONFIG: EVOConfig = {
+  origin_paths: {
+    paths: ['~/.skills', '~/.claude/skills'],
+  },
+  observer: {
+    enabled_runtimes: ['codex', 'opencode', 'claude'],
+    trace_retention_days: 30,
+  },
+  evaluator: {
+    min_signal_count: 3,
+    min_source_sessions: 2,
+    min_confidence: 0.7,
+  },
+  patch: {
+    allowed_types: ['append_context', 'tighten_trigger', 'add_fallback', 'prune_noise'],
+    cooldown_hours: 24,
+    max_patches_per_day: 3,
+  },
+  journal: {
+    snapshot_interval: 5,
+    max_snapshots: 20,
+  },
+  daemon: {
+    auto_start: true,
+    log_level: 'info',
+  },
+};