evo-skills 0.1.0

package/src/storage/markdown.ts

@@ -0,0 +1,267 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { createChildLogger } from '../utils/logger.js';
+import { hashString } from '../utils/hash.js';
+import { createUnifiedDiff } from '../utils/diff.js';
+
+const logger = createChildLogger('markdown');
+
+/**
+ * Markdown Skill 文件操作器
+ */
+export class MarkdownSkill {
+  private filePath: string;
+  private content: string = '';
+
+  constructor(filePath: string) {
+    this.filePath = filePath;
+  }
+
+  /**
+   * 读取文件内容
+   */
+  read(): string {
+    if (!existsSync(this.filePath)) {
+      throw new Error(`Skill file not found: ${this.filePath}`);
+    }
+    this.content = readFileSync(this.filePath, 'utf-8');
+    return this.content;
+  }
+
+  /**
+   * 写入文件内容
+   */
+  write(content: string): void {
+    const dir = dirname(this.filePath);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    writeFileSync(this.filePath, content, 'utf-8');
+    this.content = content;
+    logger.debug('Skill file written', { path: this.filePath });
+  }
+
+  /**
+   * 获取当前内容
+   */
+  getContent(): string {
+    return this.content;
+  }
+
+  /**
+   * 获取内容哈希
+   */
+  getContentHash(): string {
+    return hashString(this.content);
+  }
+
+  /**
+   * 检查文件是否存在
+   */
+  exists(): boolean {
+    return existsSync(this.filePath);
+  }
+
+  /**
+   * 获取文件路径
+   */
+  getPath(): string {
+    return this.filePath;
+  }
+
+  /**
+   * 解析 frontmatter
+   */
+  parseFrontmatter(): Record<string, unknown> {
+    const frontmatter: Record<string, unknown> = {};
+    const lines = this.content.split('\n');
+
+    if (lines[0]?.trim() !== '---') {
+      return frontmatter;
+    }
+
+    let endIndex = -1;
+    for (let i = 1; i < lines.length; i++) {
+      if (lines[i]?.trim() === '---') {
+        endIndex = i;
+        break;
+      }
+    }
+
+    if (endIndex === -1) {
+      return frontmatter;
+    }
+
+    for (let i = 1; i < endIndex; i++) {
+      const line = lines[i];
+      const colonIndex = line?.indexOf(':') ?? -1;
+      if (colonIndex > 0) {
+        const key = line?.substring(0, colonIndex).trim();
+        const value = line?.substring(colonIndex + 1).trim();
+        if (key) {
+          frontmatter[key] = value;
+        }
+      }
+    }
+
+    return frontmatter;
+  }
+
+  /**
+   * 更新 frontmatter
+   */
+  updateFrontmatter(updates: Record<string, unknown>): string {
+    const lines = this.content.split('\n');
+
+    if (lines[0]?.trim() !== '---') {
+      // 没有 frontmatter，添加一个
+      const newFrontmatter = Object.entries(updates)
+        .map(([k, v]) => `${k}: ${v}`)
+        .join('\n');
+      const newContent = `---\n${newFrontmatter}\n---\n\n${this.content}`;
+      this.write(newContent);
+      return newContent;
+    }
+
+    let endIndex = -1;
+    for (let i = 1; i < lines.length; i++) {
+      if (lines[i]?.trim() === '---') {
+        endIndex = i;
+        break;
+      }
+    }
+
+    if (endIndex === -1) {
+      return this.content;
+    }
+
+    // 解析现有 frontmatter
+    const existingFrontmatter = this.parseFrontmatter();
+    const mergedFrontmatter = { ...existingFrontmatter, ...updates };
+
+    // 重建 frontmatter
+    const newFrontmatterLines = Object.entries(mergedFrontmatter).map(
+      ([k, v]) => `${k}: ${v}`
+    );
+
+    const newContent = [
+      '---',
+      ...newFrontmatterLines,
+      '---',
+      ...lines.slice(endIndex + 1),
+    ].join('\n');
+
+    this.write(newContent);
+    return newContent;
+  }
+
+  /**
+   * 查找 section
+   */
+  findSection(heading: string): { start: number; end: number; content: string } | null {
+    const lines = this.content.split('\n');
+    const headingPattern = new RegExp(`^#{1,6}\\s+${heading}`, 'i');
+
+    let start = -1;
+    let headingLevel = 0;
+
+    for (let i = 0; i < lines.length; i++) {
+      if (headingPattern.test(lines[i] ?? '')) {
+        start = i;
+        headingLevel = (lines[i]?.match(/^(#{1,6})/) ?? ['', ''])[1].length;
+        break;
+      }
+    }
+
+    if (start === -1) {
+      return null;
+    }
+
+    // 找到下一个同级或更高级的 heading
+    let end = lines.length;
+    for (let i = start + 1; i < lines.length; i++) {
+      const match = lines[i]?.match(/^(#{1,6})\s/);
+      if (match && match[1].length <= headingLevel) {
+        end = i;
+        break;
+      }
+    }
+
+    return {
+      start,
+      end,
+      content: lines.slice(start, end).join('\n'),
+    };
+  }
+
+  /**
+   * 替换 section 内容
+   */
+  replaceSection(heading: string, newContent: string): string {
+    const section = this.findSection(heading);
+    if (!section) {
+      logger.warn(`Section not found: ${heading}`);
+      return this.content;
+    }
+
+    const lines = this.content.split('\n');
+    const newLines = [
+      ...lines.slice(0, section.start + 1),
+      ...newContent.split('\n'),
+      ...lines.slice(section.end),
+    ];
+
+    const result = newLines.join('\n');
+    this.write(result);
+    return result;
+  }
+
+  /**
+   * 在指定 section 后追加内容
+   */
+  appendAfterSection(heading: string, content: string): string {
+    const section = this.findSection(heading);
+    if (!section) {
+      logger.warn(`Section not found: ${heading}`);
+      return this.content;
+    }
+
+    const lines = this.content.split('\n');
+    const newLines = [
+      ...lines.slice(0, section.end),
+      '',
+      content,
+      '',
+      ...lines.slice(section.end),
+    ];
+
+    const result = newLines.join('\n');
+    this.write(result);
+    return result;
+  }
+
+  /**
+   * 生成 diff
+   */
+  generateDiff(oldContent: string, newContent: string): string {
+    return createUnifiedDiff(this.filePath, oldContent, newContent);
+  }
+
+  /**
+   * 从 origin 复制
+   */
+  copyFromOrigin(originPath: string): void {
+    if (!existsSync(originPath)) {
+      throw new Error(`Origin skill not found: ${originPath}`);
+    }
+
+    const originContent = readFileSync(originPath, 'utf-8');
+    this.write(originContent);
+    logger.info('Skill copied from origin', { from: originPath, to: this.filePath });
+  }
+}
+
+// 导出工厂函数
+export function createMarkdownSkill(filePath: string): MarkdownSkill {
+  return new MarkdownSkill(filePath);
+}

package/src/storage/ndjson.ts

@@ -0,0 +1,273 @@
+import { createReadStream, createWriteStream, existsSync, mkdirSync, appendFileSync } from 'node:fs';
+import { createInterface } from 'node:readline';
+import { join, dirname } from 'node:path';
+import { createChildLogger } from '../utils/logger.js';
+import type { Trace, EvolutionRecord } from '../types/index.js';
+
+const logger = createChildLogger('ndjson');
+
+/**
+ * NDJSON 读写器
+ */
+export class NDJSONReader<T> {
+  private filePath: string;
+
+  constructor(filePath: string) {
+    this.filePath = filePath;
+  }
+
+  /**
+   * 检查文件是否存在
+   */
+  exists(): boolean {
+    return existsSync(this.filePath);
+  }
+
+  /**
+   * 逐行读取并解析
+   */
+  async *readLines(): AsyncGenerator<T> {
+    if (!this.exists()) {
+      return;
+    }
+
+    const stream = createReadStream(this.filePath, { encoding: 'utf-8' });
+    const rl = createInterface({
+      input: stream,
+      crlfDelay: Infinity,
+    });
+
+    let lineNumber = 0;
+    for await (const line of rl) {
+      lineNumber++;
+      if (line.trim() === '') continue;
+
+      try {
+        const item = JSON.parse(line) as T;
+        yield item;
+      } catch (error) {
+        logger.warn(`Failed to parse line ${lineNumber}`, { error, line: line.substring(0, 100) });
+      }
+    }
+  }
+
+  /**
+   * 读取所有记录
+   */
+  async readAll(): Promise<T[]> {
+    const records: T[] = [];
+    for await (const record of this.readLines()) {
+      records.push(record);
+    }
+    return records;
+  }
+
+  /**
+   * 读取最后 N 条记录
+   */
+  async readLast(n: number): Promise<T[]> {
+    const allRecords = await this.readAll();
+    return allRecords.slice(-n);
+  }
+
+  /**
+   * 按条件过滤
+   */
+  async *filter(predicate: (item: T) => boolean): AsyncGenerator<T> {
+    for await (const item of this.readLines()) {
+      if (predicate(item)) {
+        yield item;
+      }
+    }
+  }
+
+  /**
+   * 统计记录数
+   */
+  async count(): Promise<number> {
+    let count = 0;
+    for await (const _ of this.readLines()) {
+      count++;
+    }
+    return count;
+  }
+}
+
+/**
+ * NDJSON 写入器
+ */
+export class NDJSONWriter<T> {
+  private filePath: string;
+
+  constructor(filePath: string) {
+    this.filePath = filePath;
+    this.ensureDirectory();
+  }
+
+  /**
+   * 确保目录存在
+   */
+  private ensureDirectory(): void {
+    const dir = dirname(this.filePath);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+  }
+
+  /**
+   * 追加一条记录
+   */
+  append(record: T): void {
+    const line = JSON.stringify(record) + '\n';
+    appendFileSync(this.filePath, line, 'utf-8');
+  }
+
+  /**
+   * 批量追加记录
+   */
+  appendBatch(records: T[]): void {
+    const lines = records.map((r) => JSON.stringify(r)).join('\n') + '\n';
+    appendFileSync(this.filePath, lines, 'utf-8');
+  }
+
+  /**
+   * 清空文件
+   */
+  clear(): void {
+    const stream = createWriteStream(this.filePath, { flags: 'w' });
+    stream.end();
+  }
+
+  /**
+   * 获取文件路径
+   */
+  getPath(): string {
+    return this.filePath;
+  }
+}
+
+/**
+ * Trace NDJSON 存储
+ */
+export class TraceStore {
+  private writer: NDJSONWriter<Trace>;
+  private reader: NDJSONReader<Trace>;
+
+  constructor(tracesDir: string, sessionId: string) {
+    const filePath = join(tracesDir, `${sessionId}.ndjson`);
+    this.writer = new NDJSONWriter<Trace>(filePath);
+    this.reader = new NDJSONReader<Trace>(filePath);
+  }
+
+  /**
+   * 记录 trace
+   */
+  append(trace: Trace): void {
+    this.writer.append(trace);
+    logger.debug('Trace appended', { trace_id: trace.trace_id, event_type: trace.event_type });
+  }
+
+  /**
+   * 读取所有 traces
+   */
+  async readAll(): Promise<Trace[]> {
+    return this.reader.readAll();
+  }
+
+  /**
+   * 读取 session 的 traces
+   */
+  async readBySession(sessionId: string): Promise<Trace[]> {
+    const traces: Trace[] = [];
+    for await (const trace of this.reader.filter((t) => t.session_id === sessionId)) {
+      traces.push(trace);
+    }
+    return traces;
+  }
+
+  /**
+   * 读取最近的 traces
+   */
+  async readRecent(count: number): Promise<Trace[]> {
+    return this.reader.readLast(count);
+  }
+}
+
+/**
+ * Journal NDJSON 存储
+ */
+export class JournalStore {
+  private writer: NDJSONWriter<EvolutionRecord>;
+  private reader: NDJSONReader<EvolutionRecord>;
+
+  constructor(journalPath: string) {
+    this.writer = new NDJSONWriter<EvolutionRecord>(journalPath);
+    this.reader = new NDJSONReader<EvolutionRecord>(journalPath);
+  }
+
+  /**
+   * 记录演化
+   */
+  append(record: EvolutionRecord): void {
+    this.writer.append(record);
+    logger.info('Evolution record appended', {
+      shadow_id: record.shadow_id,
+      revision: record.revision,
+      change_type: record.change_type,
+    });
+  }
+
+  /**
+   * 读取所有记录
+   */
+  async readAll(): Promise<EvolutionRecord[]> {
+    return this.reader.readAll();
+  }
+
+  /**
+   * 读取指定 revision 范围的记录
+   */
+  async readRange(fromRevision: number, toRevision: number): Promise<EvolutionRecord[]> {
+    const records: EvolutionRecord[] = [];
+    for await (const record of this.reader.filter(
+      (r) => r.revision >= fromRevision && r.revision <= toRevision
+    )) {
+      records.push(record);
+    }
+    return records;
+  }
+
+  /**
+   * 读取最后 N 条记录
+   */
+  async readLast(n: number): Promise<EvolutionRecord[]> {
+    return this.reader.readLast(n);
+  }
+
+  /**
+   * 获取最新 revision
+   */
+  async getLatestRevision(): Promise<number> {
+    const records = await this.reader.readLast(1);
+    return records.length > 0 ? records[0].revision : 0;
+  }
+
+  /**
+   * 获取指定 revision 的记录
+   */
+  async getByRevision(revision: number): Promise<EvolutionRecord | null> {
+    for await (const record of this.reader.filter((r) => r.revision === revision)) {
+      return record;
+    }
+    return null;
+  }
+}
+
+// 导出工厂函数
+export function createTraceStore(tracesDir: string, sessionId: string): TraceStore {
+  return new TraceStore(tracesDir, sessionId);
+}
+
+export function createJournalStore(journalPath: string): JournalStore {
+  return new JournalStore(journalPath);
+}