opc-agent 4.1.0 → 4.1.2

package/src/mcp/servers/web-mcp.ts

@@ -1,49 +1,49 @@
-import type { MCPServerConfig } from '../../protocols/mcp/types';
-
-export function createWebServer(): MCPServerConfig {
-  return {
-    name: 'web',
-    version: '1.0.0',
-    tools: [
-      {
-        name: 'web_fetch',
-        description: 'Fetch a URL and return its content',
-        inputSchema: { type: 'object', properties: { url: { type: 'string' }, method: { type: 'string', default: 'GET' }, headers: { type: 'object' }, body: { type: 'string' } }, required: ['url'] },
-        handler: async (args: { url: string; method?: string; headers?: Record<string, string>; body?: string }) => {
-          const res = await fetch(args.url, { method: args.method || 'GET', headers: args.headers, body: args.body });
-          const contentType = res.headers.get('content-type') || '';
-          const text = await res.text();
-          return { status: res.status, contentType, body: text.slice(0, 50000), truncated: text.length > 50000 };
-        },
-      },
-      {
-        name: 'web_extract_text',
-        description: 'Fetch a URL and extract readable text (strips HTML tags)',
-        inputSchema: { type: 'object', properties: { url: { type: 'string' } }, required: ['url'] },
-        handler: async (args: { url: string }) => {
-          const res = await fetch(args.url);
-          const html = await res.text();
-          const text = html.replace(/<script[\s\S]*?<\/script>/gi, '').replace(/<style[\s\S]*?<\/style>/gi, '').replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ').trim();
-          return { text: text.slice(0, 30000), truncated: text.length > 30000 };
-        },
-      },
-      {
-        name: 'web_search',
-        description: 'Search the web (simulated — returns search URL for manual use)',
-        inputSchema: { type: 'object', properties: { query: { type: 'string' }, engine: { type: 'string', enum: ['google', 'bing', 'duckduckgo'], default: 'duckduckgo' } }, required: ['query'] },
-        handler: async (args: { query: string; engine?: string }) => {
-          const engines: Record<string, string> = {
-            google: `https://www.google.com/search?q=${encodeURIComponent(args.query)}`,
-            bing: `https://www.bing.com/search?q=${encodeURIComponent(args.query)}`,
-            duckduckgo: `https://html.duckduckgo.com/html/?q=${encodeURIComponent(args.query)}`,
-          };
-          const url = engines[args.engine || 'duckduckgo'];
-          const res = await fetch(url, { headers: { 'User-Agent': 'Mozilla/5.0 opc-mcp/1.0' } });
-          const html = await res.text();
-          const text = html.replace(/<script[\s\S]*?<\/script>/gi, '').replace(/<style[\s\S]*?<\/style>/gi, '').replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ').trim();
-          return { query: args.query, engine: args.engine || 'duckduckgo', results: text.slice(0, 20000) };
-        },
-      },
-    ],
-  };
-}
+import type { MCPServerConfig } from '../../protocols/mcp/types';
+
+export function createWebServer(): MCPServerConfig {
+  return {
+    name: 'web',
+    version: '1.0.0',
+    tools: [
+      {
+        name: 'web_fetch',
+        description: 'Fetch a URL and return its content',
+        inputSchema: { type: 'object', properties: { url: { type: 'string' }, method: { type: 'string', default: 'GET' }, headers: { type: 'object' }, body: { type: 'string' } }, required: ['url'] },
+        handler: async (args: { url: string; method?: string; headers?: Record<string, string>; body?: string }) => {
+          const res = await fetch(args.url, { method: args.method || 'GET', headers: args.headers, body: args.body });
+          const contentType = res.headers.get('content-type') || '';
+          const text = await res.text();
+          return { status: res.status, contentType, body: text.slice(0, 50000), truncated: text.length > 50000 };
+        },
+      },
+      {
+        name: 'web_extract_text',
+        description: 'Fetch a URL and extract readable text (strips HTML tags)',
+        inputSchema: { type: 'object', properties: { url: { type: 'string' } }, required: ['url'] },
+        handler: async (args: { url: string }) => {
+          const res = await fetch(args.url);
+          const html = await res.text();
+          const text = html.replace(/<script[\s\S]*?<\/script>/gi, '').replace(/<style[\s\S]*?<\/style>/gi, '').replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ').trim();
+          return { text: text.slice(0, 30000), truncated: text.length > 30000 };
+        },
+      },
+      {
+        name: 'web_search',
+        description: 'Search the web (simulated — returns search URL for manual use)',
+        inputSchema: { type: 'object', properties: { query: { type: 'string' }, engine: { type: 'string', enum: ['google', 'bing', 'duckduckgo'], default: 'duckduckgo' } }, required: ['query'] },
+        handler: async (args: { query: string; engine?: string }) => {
+          const engines: Record<string, string> = {
+            google: `https://www.google.com/search?q=${encodeURIComponent(args.query)}`,
+            bing: `https://www.bing.com/search?q=${encodeURIComponent(args.query)}`,
+            duckduckgo: `https://html.duckduckgo.com/html/?q=${encodeURIComponent(args.query)}`,
+          };
+          const url = engines[args.engine || 'duckduckgo'];
+          const res = await fetch(url, { headers: { 'User-Agent': 'Mozilla/5.0 opc-mcp/1.0' } });
+          const html = await res.text();
+          const text = html.replace(/<script[\s\S]*?<\/script>/gi, '').replace(/<style[\s\S]*?<\/style>/gi, '').replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ').trim();
+          return { query: args.query, engine: args.engine || 'duckduckgo', results: text.slice(0, 20000) };
+        },
+      },
+    ],
+  };
+}

package/src/memory/context-compressor.ts

@@ -1,189 +1,189 @@
-import type { Message } from '../core/types';
-
-export interface CompressorConfig {
-  maxTokens: number;
-  compressThreshold: number;
-  preserveRecent: number;
-  brain?: any;
-}
-
-export interface CompressResult {
-  messages: Message[];
-  learnedCount: number;
-  savedTokens: number;
-  summary: string;
-}
-
-const DEFAULT_CONFIG: CompressorConfig = {
-  maxTokens: 8000,
-  compressThreshold: 0.8,
-  preserveRecent: 10,
-};
-
-/**
- * Context compression with optional DeepBrain memory offloading.
- */
-export class ContextCompressor {
-  private config: CompressorConfig;
-
-  constructor(config: Partial<CompressorConfig> = {}) {
-    this.config = { ...DEFAULT_CONFIG, ...config };
-  }
-
-  /**
-   * Estimate token count using language-aware heuristic.
-   * English: ~1 token per 4 chars. Chinese: ~1 token per 2 chars.
-   */
-  estimateTokens(text: string): number {
-    let tokens = 0;
-    for (const char of text) {
-      // CJK Unicode range detection
-      const code = char.codePointAt(0) ?? 0;
-      if (
-        (code >= 0x4e00 && code <= 0x9fff) ||  // CJK Unified
-        (code >= 0x3400 && code <= 0x4dbf) ||  // CJK Extension A
-        (code >= 0x3000 && code <= 0x303f)     // CJK Punctuation
-      ) {
-        tokens += 0.5; // 1 token per 2 chars
-      } else {
-        tokens += 0.25; // 1 token per 4 chars
-      }
-    }
-    return Math.ceil(tokens);
-  }
-
-  private estimateMessagesTokens(messages: Message[]): number {
-    return messages.reduce((sum, m) => sum + this.estimateTokens(m.content), 0);
-  }
-
-  /**
-   * Extract key insights from messages for brain storage.
-   */
-  private extractInsights(messages: Message[]): Array<{ content: string; type: string }> {
-    const insights: Array<{ content: string; type: string }> = [];
-    for (const msg of messages) {
-      const c = msg.content;
-      // Decisions
-      if (/\b(decided|decision|choose|chose|will use|going with|let's go|确定|决定)\b/i.test(c)) {
-        insights.push({ content: c.slice(0, 500), type: 'decision' });
-      }
-      // Facts / definitions
-      else if (/\b(is defined as|means|equals|refers to|是指|定义)\b/i.test(c)) {
-        insights.push({ content: c.slice(0, 500), type: 'fact' });
-      }
-      // Preferences
-      else if (/\b(prefer|like|want|don't like|不喜欢|喜欢|偏好)\b/i.test(c)) {
-        insights.push({ content: c.slice(0, 500), type: 'preference' });
-      }
-      // Code snippets
-      else if (/```[\s\S]{20,}```/.test(c)) {
-        insights.push({ content: c.slice(0, 800), type: 'code' });
-      }
-      // Long assistant messages likely contain useful info
-      else if (msg.role === 'assistant' && c.length > 200) {
-        insights.push({ content: c.slice(0, 500), type: 'knowledge' });
-      }
-    }
-    return insights;
-  }
-
-  /**
-   * Generate a simple summary from messages (no-brain fallback).
-   */
-  private summarize(messages: Message[]): string {
-    const topics = new Set<string>();
-    const keyLines: string[] = [];
-
-    for (const msg of messages) {
-      // Extract first meaningful sentence
-      const firstLine = msg.content.split(/[.\n!?。！？]/)[0]?.trim();
-      if (firstLine && firstLine.length > 10 && firstLine.length < 200) {
-        if (keyLines.length < 5) keyLines.push(`[${msg.role}] ${firstLine}`);
-      }
-      // Extract topic words (capitalized words, Chinese phrases)
-      const words = msg.content.match(/[A-Z][a-z]{2,}/g) ?? [];
-      words.forEach(w => topics.add(w));
-    }
-
-    const topicStr = [...topics].slice(0, 10).join(', ');
-    const linesStr = keyLines.join('; ');
-    return `Topics: ${topicStr || 'general discussion'}. Key points: ${linesStr || 'varied conversation'}`;
-  }
-
-  /**
-   * Compress messages when token count exceeds threshold.
-   */
-  async compress(messages: Message[], config?: Partial<CompressorConfig>): Promise<CompressResult> {
-    const cfg = { ...this.config, ...config };
-    const totalTokens = this.estimateMessagesTokens(messages);
-    const threshold = cfg.maxTokens * cfg.compressThreshold;
-
-    // Under threshold — return as-is
-    if (totalTokens <= threshold) {
-      return {
-        messages: [...messages],
-        learnedCount: 0,
-        savedTokens: 0,
-        summary: '',
-      };
-    }
-
-    const recentCount = Math.min(cfg.preserveRecent, messages.length);
-    const splitIdx = messages.length - recentCount;
-    const oldMessages = messages.slice(0, splitIdx);
-    const recentMessages = messages.slice(splitIdx);
-
-    if (oldMessages.length === 0) {
-      return { messages: [...messages], learnedCount: 0, savedTokens: 0, summary: '' };
-    }
-
-    const oldTokens = this.estimateMessagesTokens(oldMessages);
-    let learnedCount = 0;
-    let summary: string;
-
-    if (cfg.brain) {
-      // Extract and learn insights
-      const insights = this.extractInsights(oldMessages);
-      for (const insight of insights) {
-        try {
-          await cfg.brain.learn(insight.content, { insight_type: insight.type });
-          learnedCount++;
-        } catch { /* non-critical */ }
-      }
-      summary = `${oldMessages.length} messages compressed. Extracted ${learnedCount} insights (${insights.map(i => i.type).filter((v, i, a) => a.indexOf(v) === i).join(', ')}).`;
-    } else {
-      summary = this.summarize(oldMessages);
-    }
-
-    const compressionMessage: Message = {
-      id: `compressed-${Date.now()}`,
-      role: 'system',
-      content: `[Context compressed: ${oldMessages.length} messages → ${summary}${cfg.brain ? ' Details stored in Brain, use recall() to retrieve.' : ''}]`,
-      timestamp: Date.now(),
-    };
-
-    return {
-      messages: [compressionMessage, ...recentMessages],
-      learnedCount,
-      savedTokens: oldTokens - this.estimateTokens(compressionMessage.content),
-      summary,
-    };
-  }
-
-  /**
-   * Restore context from brain for a given query.
-   */
-  async restore(query: string, brain: any): Promise<string[]> {
-    if (!brain?.recall) return [];
-    try {
-      const results = await brain.recall(query);
-      if (Array.isArray(results)) {
-        return results.map((r: any) => typeof r === 'string' ? r : r.content ?? JSON.stringify(r));
-      }
-      if (typeof results === 'string') return [results];
-      return [];
-    } catch {
-      return [];
-    }
-  }
-}
+import type { Message } from '../core/types';
+
+export interface CompressorConfig {
+  maxTokens: number;
+  compressThreshold: number;
+  preserveRecent: number;
+  brain?: any;
+}
+
+export interface CompressResult {
+  messages: Message[];
+  learnedCount: number;
+  savedTokens: number;
+  summary: string;
+}
+
+const DEFAULT_CONFIG: CompressorConfig = {
+  maxTokens: 8000,
+  compressThreshold: 0.8,
+  preserveRecent: 10,
+};
+
+/**
+ * Context compression with optional DeepBrain memory offloading.
+ */
+export class ContextCompressor {
+  private config: CompressorConfig;
+
+  constructor(config: Partial<CompressorConfig> = {}) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+  }
+
+  /**
+   * Estimate token count using language-aware heuristic.
+   * English: ~1 token per 4 chars. Chinese: ~1 token per 2 chars.
+   */
+  estimateTokens(text: string): number {
+    let tokens = 0;
+    for (const char of text) {
+      // CJK Unicode range detection
+      const code = char.codePointAt(0) ?? 0;
+      if (
+        (code >= 0x4e00 && code <= 0x9fff) ||  // CJK Unified
+        (code >= 0x3400 && code <= 0x4dbf) ||  // CJK Extension A
+        (code >= 0x3000 && code <= 0x303f)     // CJK Punctuation
+      ) {
+        tokens += 0.5; // 1 token per 2 chars
+      } else {
+        tokens += 0.25; // 1 token per 4 chars
+      }
+    }
+    return Math.ceil(tokens);
+  }
+
+  private estimateMessagesTokens(messages: Message[]): number {
+    return messages.reduce((sum, m) => sum + this.estimateTokens(m.content), 0);
+  }
+
+  /**
+   * Extract key insights from messages for brain storage.
+   */
+  private extractInsights(messages: Message[]): Array<{ content: string; type: string }> {
+    const insights: Array<{ content: string; type: string }> = [];
+    for (const msg of messages) {
+      const c = msg.content;
+      // Decisions
+      if (/\b(decided|decision|choose|chose|will use|going with|let's go|确定|决定)\b/i.test(c)) {
+        insights.push({ content: c.slice(0, 500), type: 'decision' });
+      }
+      // Facts / definitions
+      else if (/\b(is defined as|means|equals|refers to|是指|定义)\b/i.test(c)) {
+        insights.push({ content: c.slice(0, 500), type: 'fact' });
+      }
+      // Preferences
+      else if (/\b(prefer|like|want|don't like|不喜欢|喜欢|偏好)\b/i.test(c)) {
+        insights.push({ content: c.slice(0, 500), type: 'preference' });
+      }
+      // Code snippets
+      else if (/```[\s\S]{20,}```/.test(c)) {
+        insights.push({ content: c.slice(0, 800), type: 'code' });
+      }
+      // Long assistant messages likely contain useful info
+      else if (msg.role === 'assistant' && c.length > 200) {
+        insights.push({ content: c.slice(0, 500), type: 'knowledge' });
+      }
+    }
+    return insights;
+  }
+
+  /**
+   * Generate a simple summary from messages (no-brain fallback).
+   */
+  private summarize(messages: Message[]): string {
+    const topics = new Set<string>();
+    const keyLines: string[] = [];
+
+    for (const msg of messages) {
+      // Extract first meaningful sentence
+      const firstLine = msg.content.split(/[.\n!?。！？]/)[0]?.trim();
+      if (firstLine && firstLine.length > 10 && firstLine.length < 200) {
+        if (keyLines.length < 5) keyLines.push(`[${msg.role}] ${firstLine}`);
+      }
+      // Extract topic words (capitalized words, Chinese phrases)
+      const words = msg.content.match(/[A-Z][a-z]{2,}/g) ?? [];
+      words.forEach(w => topics.add(w));
+    }
+
+    const topicStr = [...topics].slice(0, 10).join(', ');
+    const linesStr = keyLines.join('; ');
+    return `Topics: ${topicStr || 'general discussion'}. Key points: ${linesStr || 'varied conversation'}`;
+  }
+
+  /**
+   * Compress messages when token count exceeds threshold.
+   */
+  async compress(messages: Message[], config?: Partial<CompressorConfig>): Promise<CompressResult> {
+    const cfg = { ...this.config, ...config };
+    const totalTokens = this.estimateMessagesTokens(messages);
+    const threshold = cfg.maxTokens * cfg.compressThreshold;
+
+    // Under threshold — return as-is
+    if (totalTokens <= threshold) {
+      return {
+        messages: [...messages],
+        learnedCount: 0,
+        savedTokens: 0,
+        summary: '',
+      };
+    }
+
+    const recentCount = Math.min(cfg.preserveRecent, messages.length);
+    const splitIdx = messages.length - recentCount;
+    const oldMessages = messages.slice(0, splitIdx);
+    const recentMessages = messages.slice(splitIdx);
+
+    if (oldMessages.length === 0) {
+      return { messages: [...messages], learnedCount: 0, savedTokens: 0, summary: '' };
+    }
+
+    const oldTokens = this.estimateMessagesTokens(oldMessages);
+    let learnedCount = 0;
+    let summary: string;
+
+    if (cfg.brain) {
+      // Extract and learn insights
+      const insights = this.extractInsights(oldMessages);
+      for (const insight of insights) {
+        try {
+          await cfg.brain.learn(insight.content, { insight_type: insight.type });
+          learnedCount++;
+        } catch { /* non-critical */ }
+      }
+      summary = `${oldMessages.length} messages compressed. Extracted ${learnedCount} insights (${insights.map(i => i.type).filter((v, i, a) => a.indexOf(v) === i).join(', ')}).`;
+    } else {
+      summary = this.summarize(oldMessages);
+    }
+
+    const compressionMessage: Message = {
+      id: `compressed-${Date.now()}`,
+      role: 'system',
+      content: `[Context compressed: ${oldMessages.length} messages → ${summary}${cfg.brain ? ' Details stored in Brain, use recall() to retrieve.' : ''}]`,
+      timestamp: Date.now(),
+    };
+
+    return {
+      messages: [compressionMessage, ...recentMessages],
+      learnedCount,
+      savedTokens: oldTokens - this.estimateTokens(compressionMessage.content),
+      summary,
+    };
+  }
+
+  /**
+   * Restore context from brain for a given query.
+   */
+  async restore(query: string, brain: any): Promise<string[]> {
+    if (!brain?.recall) return [];
+    try {
+      const results = await brain.recall(query);
+      if (Array.isArray(results)) {
+        return results.map((r: any) => typeof r === 'string' ? r : r.content ?? JSON.stringify(r));
+      }
+      if (typeof results === 'string') return [results];
+      return [];
+    } catch {
+      return [];
+    }
+  }
+}

package/src/memory/deepbrain.ts

@@ -1,9 +1,103 @@
 import type { Message, MemoryStore } from '../core/types';
 import { InMemoryStore } from './index';
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join, resolve } from 'path';
+
+/**
+ * 本地 JSON 文件持久化存储，作为 DeepBrain 不可用时的 fallback。
+ * 数据保存在 .opc/memory.json，进程重启后记忆不会丢失。
+ */
+class FileBackedStore implements MemoryStore {
+  private store: Map<string, unknown> = new Map();
+  private conversations: Map<string, Message[]> = new Map();
+  private filePath: string;
+  private dirty = false;
+  private saveTimer: ReturnType<typeof setTimeout> | null = null;
+
+  constructor(baseDir: string = '.') {
+    const opcDir = join(resolve(baseDir), '.opc');
+    if (!existsSync(opcDir)) mkdirSync(opcDir, { recursive: true });
+    this.filePath = join(opcDir, 'memory.json');
+    this.loadFromFile();
+  }
+
+  private loadFromFile(): void {
+    if (!existsSync(this.filePath)) return;
+    try {
+      const data = JSON.parse(readFileSync(this.filePath, 'utf-8'));
+      if (data.store) {
+        for (const [k, v] of Object.entries(data.store)) {
+          this.store.set(k, v);
+        }
+      }
+      if (data.conversations) {
+        for (const [k, v] of Object.entries(data.conversations)) {
+          this.conversations.set(k, v as Message[]);
+        }
+      }
+    } catch { /* 文件损坏则忽略，从空开始 */ }
+  }
+
+  private scheduleSave(): void {
+    this.dirty = true;
+    if (this.saveTimer) return; // 已经有定时器在等了
+    // 延迟 1 秒批量写入，避免高频写磁盘
+    this.saveTimer = setTimeout(() => {
+      this.saveTimer = null;
+      if (this.dirty) this.saveToFile();
+    }, 1000);
+  }
+
+  private saveToFile(): void {
+    try {
+      const data = {
+        store: Object.fromEntries(this.store),
+        conversations: Object.fromEntries(this.conversations),
+        updatedAt: new Date().toISOString(),
+      };
+      writeFileSync(this.filePath, JSON.stringify(data, null, 2));
+      this.dirty = false;
+    } catch { /* 写入失败不影响运行 */ }
+  }
+
+  async get(key: string): Promise<unknown> {
+    return this.store.get(key);
+  }
+
+  async set(key: string, value: unknown): Promise<void> {
+    this.store.set(key, value);
+    this.scheduleSave();
+  }
+
+  async getConversation(sessionId: string): Promise<Message[]> {
+    return this.conversations.get(sessionId) ?? [];
+  }
+
+  async addMessage(sessionId: string, message: Message): Promise<void> {
+    if (!this.conversations.has(sessionId)) {
+      this.conversations.set(sessionId, []);
+    }
+    const conv = this.conversations.get(sessionId)!;
+    conv.push(message);
+    // 每个 session 最多保留 200 条消息，避免文件无限增长
+    if (conv.length > 200) conv.splice(0, conv.length - 200);
+    this.scheduleSave();
+  }
+
+  async clear(sessionId?: string): Promise<void> {
+    if (sessionId) {
+      this.conversations.delete(sessionId);
+    } else {
+      this.store.clear();
+      this.conversations.clear();
+    }
+    this.scheduleSave();
+  }
+}
 
 /**
  * DeepBrain-backed memory store for long-term semantic memory.
- * Falls back to InMemoryStore if deepbrain package is not installed.
+ * Falls back to local JSON file storage (.opc/memory.json) if deepbrain package is not installed.
  */
 export interface DeepBrainClient {
   store(collection: string, id: string, content: string, metadata?: Record<string, unknown>): Promise<void>;
@@ -12,13 +106,13 @@ export interface DeepBrainClient {
 }
 
 export class DeepBrainMemoryStore implements MemoryStore {
-  private fallback: InMemoryStore;
+  private fallback: FileBackedStore;
   private client: DeepBrainClient | null = null;
   private collection: string;
   private ready: Promise<boolean>;
 
   constructor(options: { collection?: string; config?: Record<string, unknown> } = {}) {
-    this.fallback = new InMemoryStore();
+    this.fallback = new FileBackedStore();
     this.collection = options.collection ?? 'agent-memory';
     this.ready = this.initClient(options.config);
   }
@@ -29,12 +123,12 @@ export class DeepBrainMemoryStore implements MemoryStore {
       const deepbrain = await import(/* webpackIgnore: true */ 'deepbrain');
       this.client = (deepbrain as any).createClient?.(config) ?? (deepbrain as any).default?.createClient?.(config);
       if (!this.client) {
-        console.warn('[DeepBrainMemory] Could not create client, using in-memory fallback');
+        console.warn('[DeepBrainMemory] Could not create client, using file-backed fallback (.opc/memory.json)');
         return false;
       }
       return true;
     } catch {
-      console.warn('[DeepBrainMemory] deepbrain package not found, using in-memory fallback');
+      console.warn('[DeepBrainMemory] deepbrain package not found, using file-backed fallback (.opc/memory.json)');
       return false;
     }
   }