opc-agent 4.1.2 → 4.1.4

package/src/memory/user-profiler.ts

@@ -1,215 +0,0 @@
-import type { Message } from '../core/types';
-
-export interface UserProfile {
-  preferences: Record<string, string>;
-  communication_style: string;
-  expertise_areas: string[];
-  common_requests: string[];
-  last_updated: number;
-}
-
-const EMPTY_PROFILE: UserProfile = {
-  preferences: {},
-  communication_style: 'unknown',
-  expertise_areas: [],
-  common_requests: [],
-  last_updated: 0,
-};
-
-/**
- * DeepBrain-powered user profiling from conversation signals.
- */
-export class UserProfiler {
-  private observationCount = 0;
-  private signals = {
-    languages: new Map<string, number>(),
-    techKeywords: new Set<string>(),
-    styleSignals: { brief: 0, detailed: 0, formal: 0, casual: 0 },
-    requestTypes: new Map<string, number>(),
-  };
-
-  private readonly LEARN_INTERVAL = 20;
-
-  /**
-   * Detect language mix of a text.
-   */
-  private detectLanguage(text: string): string {
-    let cn = 0, en = 0;
-    for (const char of text) {
-      const code = char.codePointAt(0) ?? 0;
-      if (code >= 0x4e00 && code <= 0x9fff) cn++;
-      else if ((code >= 0x41 && code <= 0x5a) || (code >= 0x61 && code <= 0x7a)) en++;
-    }
-    if (cn > 0 && en > 0) return 'mixed';
-    if (cn > en) return 'chinese';
-    return 'english';
-  }
-
-  /**
-   * Detect technical level from content.
-   */
-  private detectTechLevel(text: string): string {
-    const expertTerms = /\b(kubernetes|k8s|microservice|architecture|distributed|consensus|raft|paxos|sharding|vector db|embedding|fine-?tun|transformer|CUDA|inference|quantiz|LoRA|RAG)\b/i;
-    const intermediateTerms = /\b(API|REST|GraphQL|Docker|CI\/CD|database|deploy|cloud|React|TypeScript|Python|async|cache|redis|nginx)\b/i;
-
-    if (expertTerms.test(text)) return 'expert';
-    if (intermediateTerms.test(text)) return 'intermediate';
-    return 'beginner';
-  }
-
-  /**
-   * Detect communication style.
-   */
-  private detectStyle(text: string): void {
-    if (text.length < 50) this.signals.styleSignals.brief++;
-    else if (text.length > 300) this.signals.styleSignals.detailed++;
-
-    if (/\b(please|kindly|would you|could you|请问|烦请|麻烦)\b/i.test(text)) {
-      this.signals.styleSignals.formal++;
-    }
-    if (/[!]{2,}|lol|haha|😂|🤣|哈哈|牛|666|👍/i.test(text)) {
-      this.signals.styleSignals.casual++;
-    }
-  }
-
-  /**
-   * Extract domain keywords.
-   */
-  private extractDomainKeywords(text: string): void {
-    const techWords = text.match(/\b[A-Z][a-zA-Z]{2,}(?:\.js|\.ts|\.py)?\b/g) ?? [];
-    techWords.forEach(w => this.signals.techKeywords.add(w));
-    // Chinese tech terms
-    const cnTerms = text.match(/(?:人工智能|机器学习|深度学习|大模型|微服务|架构|部署|运维|前端|后端|数据库|缓存|分布式)/g) ?? [];
-    cnTerms.forEach(w => this.signals.techKeywords.add(w));
-  }
-
-  /**
-   * Classify request type.
-   */
-  private classifyRequest(text: string): string {
-    if (/\b(how to|怎么|如何|how do)\b/i.test(text)) return 'how-to';
-    if (/\b(why|为什么|原因)\b/i.test(text)) return 'explanation';
-    if (/\b(fix|error|bug|报错|出错|failed)\b/i.test(text)) return 'debugging';
-    if (/\b(review|评审|看看|check)\b/i.test(text)) return 'review';
-    if (/\b(create|build|write|写|创建|生成)\b/i.test(text)) return 'creation';
-    return 'general';
-  }
-
-  /**
-   * Observe a user message and accumulate profile signals.
-   */
-  async observe(message: Message, brain?: any): Promise<void> {
-    if (message.role !== 'user') return;
-
-    const text = message.content;
-
-    // Language
-    const lang = this.detectLanguage(text);
-    this.signals.languages.set(lang, (this.signals.languages.get(lang) ?? 0) + 1);
-
-    // Style
-    this.detectStyle(text);
-
-    // Domain keywords
-    this.extractDomainKeywords(text);
-
-    // Request type
-    const reqType = this.classifyRequest(text);
-    this.signals.requestTypes.set(reqType, (this.signals.requestTypes.get(reqType) ?? 0) + 1);
-
-    this.observationCount++;
-
-    // Periodically persist to brain
-    if (brain?.learn && this.observationCount % this.LEARN_INTERVAL === 0) {
-      const profile = this.buildProfileFromSignals();
-      try {
-        await brain.learn(JSON.stringify(profile), { insight_type: 'user_profile' });
-      } catch { /* non-critical */ }
-    }
-  }
-
-  private buildProfileFromSignals(): UserProfile {
-    // Language preference
-    let topLang = 'english';
-    let maxCount = 0;
-    for (const [lang, count] of this.signals.languages) {
-      if (count > maxCount) { topLang = lang; maxCount = count; }
-    }
-
-    // Communication style
-    const ss = this.signals.styleSignals;
-    const styles = [
-      ['brief', ss.brief], ['detailed', ss.detailed],
-      ['formal', ss.formal], ['casual', ss.casual],
-    ] as const;
-    const topStyle = styles.reduce((a, b) => (b[1] > a[1] ? b : a))[0];
-
-    // Top request types
-    const topRequests = [...this.signals.requestTypes.entries()]
-      .sort((a, b) => b[1] - a[1])
-      .slice(0, 5)
-      .map(([t]) => t);
-
-    return {
-      preferences: { language: topLang },
-      communication_style: topStyle,
-      expertise_areas: [...this.signals.techKeywords].slice(0, 20),
-      common_requests: topRequests,
-      last_updated: Date.now(),
-    };
-  }
-
-  /**
-   * Get user profile, optionally from brain recall.
-   */
-  async getProfile(brain?: any): Promise<UserProfile> {
-    // First try local signals
-    if (this.observationCount > 0) {
-      return this.buildProfileFromSignals();
-    }
-
-    // Fallback to brain recall
-    if (brain?.recall) {
-      try {
-        const results = await brain.recall('user profile preferences style');
-        if (Array.isArray(results) && results.length > 0) {
-          const raw = typeof results[0] === 'string' ? results[0] : results[0].content;
-          return { ...EMPTY_PROFILE, ...JSON.parse(raw) };
-        }
-      } catch { /* ignore parse errors */ }
-    }
-
-    return { ...EMPTY_PROFILE };
-  }
-
-  /**
-   * Enhance a system prompt with user profile context.
-   */
-  enhance(systemPrompt: string, profile: UserProfile): string {
-    const hints: string[] = [];
-
-    if (profile.preferences.language) {
-      const langMap: Record<string, string> = {
-        chinese: 'User prefers Chinese responses.',
-        english: 'User prefers English responses.',
-        mixed: 'User uses mixed Chinese/English. Match their style.',
-      };
-      if (langMap[profile.preferences.language]) hints.push(langMap[profile.preferences.language]);
-    }
-
-    if (profile.communication_style && profile.communication_style !== 'unknown') {
-      hints.push(`User communication style: ${profile.communication_style}.`);
-    }
-
-    if (profile.expertise_areas.length > 0) {
-      hints.push(`User expertise: ${profile.expertise_areas.slice(0, 10).join(', ')}.`);
-    }
-
-    if (profile.common_requests.length > 0) {
-      hints.push(`Common request types: ${profile.common_requests.join(', ')}.`);
-    }
-
-    if (hints.length === 0) return systemPrompt;
-    return `${systemPrompt}\n\n[User Profile] ${hints.join(' ')}`;
-  }
-}

package/src/plugins/content-filter.ts

@@ -1,23 +0,0 @@
-import type { Plugin } from './index';
-
-/**
- * Content filter plugin — filters messages containing blocked keywords.
- */
-export function createContentFilterPlugin(blocklist: string[] = []): Plugin {
-  return {
-    name: 'content-filter',
-    version: '1.0.0',
-    description: 'Filter inappropriate content',
-    onMessage: async (msg: any, next: (m: any) => Promise<any>) => {
-      const content = (msg.content || '').toLowerCase();
-      for (const word of blocklist) {
-        if (content.includes(word.toLowerCase())) {
-          throw new Error(`Content blocked: message contains prohibited content`);
-        }
-      }
-      return next(msg);
-    },
-  };
-}
-
-export const contentFilterPlugin: Plugin = createContentFilterPlugin([]);

package/src/plugins/index.ts

@@ -1,339 +0,0 @@
-import type { ISkill, IChannel, Message } from '../core/types';
-import type { MCPTool } from '../tools/mcp';
-import { Logger } from '../core/logger';
-
-/**
- * Plugin lifecycle hooks - v1.0.0
- */
-export interface PluginHooks {
-  onInit?: () => Promise<void>;
-  onMessage?: (message: Message) => Promise<Message | void>;
-  onResponse?: (message: Message, response: Message) => Promise<Message | void>;
-  onError?: (error: Error, context?: Record<string, unknown>) => Promise<void>;
-  onShutdown?: () => Promise<void>;
-  // Legacy aliases
-  beforeInit?: () => Promise<void>;
-  afterInit?: () => Promise<void>;
-  beforeMessage?: (message: { content: string }) => Promise<void>;
-  afterMessage?: (message: { content: string }, response: { content: string }) => Promise<void>;
-  beforeShutdown?: () => Promise<void>;
-}
-
-/**
- * v1.6.0 — Enhanced Plugin interface with middleware pattern.
- * Plugins implementing this interface use next() to chain processing.
- */
-export interface Plugin {
-  name: string;
-  version: string;
-  description?: string;
-
-  // Lifecycle hooks
-  onInit?(runtime: any): Promise<void>;
-  onMessage?(message: any, next: (msg: any) => Promise<any>): Promise<any>;
-  onResponse?(response: any, next: (res: any) => Promise<any>): Promise<any>;
-  onError?(error: Error): void;
-  onShutdown?(): Promise<void>;
-
-  // Registration
-  tools?: any[];
-  skills?: any[];
-  channels?: any[];
-}
-
-/**
- * Plugin manifest in OAD: plugins: [{ name, config }]
- */
-export interface PluginManifest {
-  name: string;
-  config?: Record<string, unknown>;
-}
-
-/**
- * Plugin interface - extend agent with skills, tools, channels, and lifecycle hooks.
- */
-export interface IPlugin {
-  name: string;
-  version: string;
-  description?: string;
-  hooks?: PluginHooks;
-  skills?: ISkill[];
-  tools?: MCPTool[];
-  channels?: IChannel[];
-}
-
-export class PluginManager {
-  private plugins: Map<string, IPlugin> = new Map();
-  private enhancedPlugins: Map<string, Plugin> = new Map();
-  private logger = new Logger('plugins');
-
-  register(plugin: IPlugin): void {
-    if (this.plugins.has(plugin.name)) {
-      this.logger.warn(`Plugin "${plugin.name}" already registered, replacing`);
-    }
-    this.plugins.set(plugin.name, plugin);
-    this.logger.info(`Plugin registered: ${plugin.name}@${plugin.version}`);
-  }
-
-  /**
-   * Register an enhanced plugin with middleware support (v1.6.0).
-   */
-  registerEnhanced(plugin: Plugin): void {
-    if (this.enhancedPlugins.has(plugin.name)) {
-      this.logger.warn(`Enhanced plugin "${plugin.name}" already registered, replacing`);
-    }
-    this.enhancedPlugins.set(plugin.name, plugin);
-    this.logger.info(`Enhanced plugin registered: ${plugin.name}@${plugin.version}`);
-  }
-
-  unregisterEnhanced(name: string): void {
-    this.enhancedPlugins.delete(name);
-  }
-
-  getEnhanced(name: string): Plugin | undefined {
-    return this.enhancedPlugins.get(name);
-  }
-
-  listEnhanced(): Plugin[] {
-    return Array.from(this.enhancedPlugins.values());
-  }
-
-  unregister(name: string): void {
-    this.plugins.delete(name);
-    this.enhancedPlugins.delete(name);
-  }
-
-  get(name: string): IPlugin | undefined {
-    return this.plugins.get(name);
-  }
-
-  list(): { name: string; version: string; description?: string }[] {
-    const legacy = Array.from(this.plugins.values()).map(({ name, version, description }) => ({
-      name, version, description,
-    }));
-    const enhanced = Array.from(this.enhancedPlugins.values()).map(({ name, version, description }) => ({
-      name, version, description,
-    }));
-    return [...legacy, ...enhanced];
-  }
-
-  has(name: string): boolean {
-    return this.plugins.has(name) || this.enhancedPlugins.has(name);
-  }
-
-  async runHook(hookName: keyof PluginHooks, ...args: unknown[]): Promise<void> {
-    for (const plugin of this.plugins.values()) {
-      const hook = plugin.hooks?.[hookName];
-      if (hook) {
-        try {
-          await (hook as (...a: unknown[]) => Promise<void>)(...args);
-        } catch (err) {
-          this.logger.error(`Plugin "${plugin.name}" hook "${hookName}" failed`, {
-            error: err instanceof Error ? err.message : String(err),
-          });
-          // Don't let one plugin break others
-        }
-      }
-    }
-  }
-
-  /**
-   * Initialize all plugins (legacy + enhanced).
-   */
-  async initAll(runtime?: any): Promise<void> {
-    await this.runOnInit();
-    for (const plugin of this.enhancedPlugins.values()) {
-      if (plugin.onInit) {
-        try {
-          await plugin.onInit(runtime);
-        } catch (err) {
-          this.logger.error(`Enhanced plugin "${plugin.name}" onInit failed`, {
-            error: err instanceof Error ? err.message : String(err),
-          });
-        }
-      }
-    }
-  }
-
-  /**
-   * Shutdown all plugins (legacy + enhanced).
-   */
-  async shutdownAll(): Promise<void> {
-    await this.runOnShutdown();
-    for (const plugin of this.enhancedPlugins.values()) {
-      if (plugin.onShutdown) {
-        try {
-          await plugin.onShutdown();
-        } catch (err) {
-          this.logger.error(`Enhanced plugin "${plugin.name}" onShutdown failed`, {
-            error: err instanceof Error ? err.message : String(err),
-          });
-        }
-      }
-    }
-  }
-
-  /**
-   * Run message through enhanced plugin middleware chain.
-   * Each plugin calls next() to pass to the next plugin.
-   */
-  async runMessageMiddleware(message: any): Promise<any> {
-    const plugins = Array.from(this.enhancedPlugins.values()).filter(p => p.onMessage);
-    if (plugins.length === 0) return message;
-
-    let index = 0;
-    const next = async (msg: any): Promise<any> => {
-      if (index >= plugins.length) return msg;
-      const plugin = plugins[index++];
-      return plugin.onMessage!(msg, next);
-    };
-    return next(message);
-  }
-
-  /**
-   * Run response through enhanced plugin middleware chain.
-   */
-  async runResponseMiddleware(response: any): Promise<any> {
-    const plugins = Array.from(this.enhancedPlugins.values()).filter(p => p.onResponse);
-    if (plugins.length === 0) return response;
-
-    let index = 0;
-    const next = async (res: any): Promise<any> => {
-      if (index >= plugins.length) return res;
-      const plugin = plugins[index++];
-      return plugin.onResponse!(res, next);
-    };
-    return next(response);
-  }
-
-  async runOnInit(): Promise<void> {
-    await this.runHook('onInit');
-    await this.runHook('beforeInit');
-    await this.runHook('afterInit');
-  }
-
-  async runOnMessage(message: Message): Promise<Message> {
-    let msg = message;
-    for (const plugin of this.plugins.values()) {
-      if (plugin.hooks?.onMessage) {
-        const result = await plugin.hooks.onMessage(msg);
-        if (result) msg = result;
-      }
-      if (plugin.hooks?.beforeMessage) {
-        await plugin.hooks.beforeMessage({ content: msg.content });
-      }
-    }
-    // Also run enhanced middleware
-    msg = await this.runMessageMiddleware(msg);
-    return msg;
-  }
-
-  async runOnResponse(message: Message, response: Message): Promise<Message> {
-    let resp = response;
-    for (const plugin of this.plugins.values()) {
-      if (plugin.hooks?.onResponse) {
-        const result = await plugin.hooks.onResponse(message, resp);
-        if (result) resp = result;
-      }
-      if (plugin.hooks?.afterMessage) {
-        await plugin.hooks.afterMessage({ content: message.content }, { content: resp.content });
-      }
-    }
-    // Also run enhanced middleware
-    resp = await this.runResponseMiddleware(resp);
-    return resp;
-  }
-
-  async runOnError(error: Error, context?: Record<string, unknown>): Promise<void> {
-    await this.runHook('onError', error, context);
-    for (const plugin of this.enhancedPlugins.values()) {
-      if (plugin.onError) {
-        try {
-          plugin.onError(error);
-        } catch (_) { /* ignore */ }
-      }
-    }
-  }
-
-  async runOnShutdown(): Promise<void> {
-    await this.runHook('onShutdown');
-    await this.runHook('beforeShutdown');
-  }
-
-  getAllSkills(): ISkill[] {
-    const skills: ISkill[] = [];
-    for (const plugin of this.plugins.values()) {
-      if (plugin.skills) skills.push(...plugin.skills);
-    }
-    return skills;
-  }
-
-  getAllTools(): MCPTool[] {
-    const tools: MCPTool[] = [];
-    for (const plugin of this.plugins.values()) {
-      if (plugin.tools) tools.push(...plugin.tools);
-    }
-    return tools;
-  }
-
-  getAllChannels(): IChannel[] {
-    const channels: IChannel[] = [];
-    for (const plugin of this.plugins.values()) {
-      if (plugin.channels) channels.push(...plugin.channels);
-    }
-    return channels;
-  }
-}
-
-// ── Built-in Plugins ────────────────────────────────────────
-
-export function createLoggingPlugin(): IPlugin {
-  const logger = new Logger('agent:messages');
-  return {
-    name: 'logging',
-    version: '1.0.0',
-    description: 'Logs all messages and responses',
-    hooks: {
-      onInit: async () => { logger.info('Agent initialized'); },
-      onMessage: async (msg: Message) => { logger.info(`← ${msg.role}: ${msg.content.slice(0, 100)}`); return undefined as any; },
-      onResponse: async (_msg: Message, resp: Message) => { logger.info(`→ ${resp.role}: ${resp.content.slice(0, 100)}`); return undefined as any; },
-      onError: async (err: Error) => { logger.error(`Error: ${err.message}`); },
-      onShutdown: async () => { logger.info('Agent shutting down'); },
-    },
-  };
-}
-
-export function createAnalyticsPlugin(): IPlugin {
-  const stats = { messages: 0, errors: 0, startedAt: 0 };
-  return {
-    name: 'analytics',
-    version: '1.0.0',
-    description: 'Tracks message counts and error rates',
-    hooks: {
-      onInit: async () => { stats.startedAt = Date.now(); },
-      onMessage: async () => { stats.messages++; return undefined as any; },
-      onError: async () => { stats.errors++; },
-    },
-  };
-}
-
-export function createRateLimitPlugin(maxPerMinute = 60): IPlugin {
-  const timestamps: number[] = [];
-  return {
-    name: 'rate-limit',
-    version: '1.0.0',
-    description: `Rate limits to ${maxPerMinute} messages/minute`,
-    hooks: {
-      onMessage: async () => {
-        const now = Date.now();
-        const windowStart = now - 60_000;
-        while (timestamps.length > 0 && timestamps[0] < windowStart) timestamps.shift();
-        if (timestamps.length >= maxPerMinute) {
-          throw new Error('Rate limit exceeded. Please slow down.');
-        }
-        timestamps.push(now);
-        return undefined as any;
-      },
-    },
-  };
-}

package/src/plugins/logger.ts

@@ -1,18 +0,0 @@
-import type { Plugin } from './index';
-
-/**
- * Logger plugin — logs all messages and responses via middleware chain.
- */
-export const loggerPlugin: Plugin = {
-  name: 'logger',
-  version: '1.0.0',
-  description: 'Log all messages and responses',
-  onMessage: async (msg: any, next: (m: any) => Promise<any>) => {
-    console.log(`[${new Date().toISOString()}] IN: ${msg.content?.slice(0, 100)}`);
-    return next(msg);
-  },
-  onResponse: async (res: any, next: (r: any) => Promise<any>) => {
-    console.log(`[${new Date().toISOString()}] OUT: ${res.content?.slice(0, 100)}`);
-    return next(res);
-  },
-};

package/src/plugins/rate-limiter.ts

@@ -1,38 +0,0 @@
-import type { Plugin } from './index';
-
-/**
- * Rate limiter plugin — limits messages per session using in-memory sliding window.
- */
-export function createRateLimiterPlugin(maxPerMinute = 60): Plugin {
-  const sessionTimestamps: Map<string, number[]> = new Map();
-
-  return {
-    name: 'rate-limiter',
-    version: '1.0.0',
-    description: `Rate limit messages per session (${maxPerMinute}/min)`,
-    onMessage: async (msg: any, next: (m: any) => Promise<any>) => {
-      const sessionId = msg.metadata?.sessionId || msg.id || 'default';
-      const now = Date.now();
-      const windowStart = now - 60_000;
-
-      if (!sessionTimestamps.has(sessionId)) {
-        sessionTimestamps.set(sessionId, []);
-      }
-      const timestamps = sessionTimestamps.get(sessionId)!;
-
-      // Remove expired timestamps
-      while (timestamps.length > 0 && timestamps[0] < windowStart) {
-        timestamps.shift();
-      }
-
-      if (timestamps.length >= maxPerMinute) {
-        throw new Error(`Rate limit exceeded: ${maxPerMinute} messages per minute`);
-      }
-
-      timestamps.push(now);
-      return next(msg);
-    },
-  };
-}
-
-export const rateLimiterPlugin: Plugin = createRateLimiterPlugin(60);