opc-agent 4.1.1 → 4.1.3

package/src/memory/context-compressor.ts

@@ -1,189 +0,0 @@
-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,108 +0,0 @@
-import type { Message, MemoryStore } from '../core/types';
-import { InMemoryStore } from './index';
-
-/**
- * DeepBrain-backed memory store for long-term semantic memory.
- * Falls back to InMemoryStore if deepbrain package is not installed.
- */
-export interface DeepBrainClient {
-  store(collection: string, id: string, content: string, metadata?: Record<string, unknown>): Promise<void>;
-  search(collection: string, query: string, limit?: number): Promise<Array<{ id: string; content: string; score: number }>>;
-  delete(collection: string, id?: string): Promise<void>;
-}
-
-export class DeepBrainMemoryStore implements MemoryStore {
-  private fallback: InMemoryStore;
-  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.collection = options.collection ?? 'agent-memory';
-    this.ready = this.initClient(options.config);
-  }
-
-  private async initClient(config?: Record<string, unknown>): Promise<boolean> {
-    try {
-      // @ts-ignore - dynamic optional dependency
-      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');
-        return false;
-      }
-      return true;
-    } catch {
-      console.warn('[DeepBrainMemory] deepbrain package not found, using in-memory fallback');
-      return false;
-    }
-  }
-
-  async get(key: string): Promise<unknown> {
-    await this.ready;
-    if (this.client) {
-      try {
-        const results = await this.client.search(this.collection, key, 1);
-        return results[0]?.content;
-      } catch {
-        return this.fallback.get(key);
-      }
-    }
-    return this.fallback.get(key);
-  }
-
-  async set(key: string, value: unknown): Promise<void> {
-    await this.ready;
-    if (this.client) {
-      try {
-        await this.client.store(this.collection, key, JSON.stringify(value));
-        return;
-      } catch { /* fallback */ }
-    }
-    return this.fallback.set(key, value);
-  }
-
-  async getConversation(sessionId: string): Promise<Message[]> {
-    return this.fallback.getConversation(sessionId);
-  }
-
-  async addMessage(sessionId: string, message: Message): Promise<void> {
-    await this.fallback.addMessage(sessionId, message);
-    // Also store in DeepBrain for semantic search
-    await this.ready;
-    if (this.client && message.role === 'user') {
-      try {
-        await this.client.store(this.collection, message.id, message.content, {
-          sessionId,
-          role: message.role,
-          timestamp: message.timestamp,
-        });
-      } catch { /* non-critical */ }
-    }
-  }
-
-  async clear(sessionId?: string): Promise<void> {
-    await this.fallback.clear(sessionId);
-    if (this.client && !sessionId) {
-      try { await this.client.delete(this.collection); } catch { /* ignore */ }
-    }
-  }
-
-  /**
-   * Semantic search over stored memories.
-   */
-  async semanticSearch(query: string, limit: number = 5): Promise<Array<{ id: string; content: string; score: number }>> {
-    await this.ready;
-    if (this.client) {
-      try {
-        return await this.client.search(this.collection, query, limit);
-      } catch { return []; }
-    }
-    return [];
-  }
-
-  isDeepBrainAvailable(): Promise<boolean> {
-    return this.ready;
-  }
-}

package/src/memory/index.ts

@@ -1,41 +0,0 @@
-import type { Message, MemoryStore } from '../core/types';
-
-export { BrainSeedLoader, KnowledgeEvolver } from './seed-loader';
-export type { BrainSeedConfig, SeedPage, SeedResult, PromotionResult, PromotionCandidate } from './seed-loader';
-export { ContextCompressor } from './context-compressor';
-export type { CompressorConfig, CompressResult } from './context-compressor';
-export { UserProfiler } from './user-profiler';
-export type { UserProfile } from './user-profiler';
-
-export class InMemoryStore implements MemoryStore {
-  private store: Map<string, unknown> = new Map();
-  private conversations: Map<string, Message[]> = new Map();
-
-  async get(key: string): Promise<unknown> {
-    return this.store.get(key);
-  }
-
-  async set(key: string, value: unknown): Promise<void> {
-    this.store.set(key, value);
-  }
-
-  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, []);
-    }
-    this.conversations.get(sessionId)!.push(message);
-  }
-
-  async clear(sessionId?: string): Promise<void> {
-    if (sessionId) {
-      this.conversations.delete(sessionId);
-    } else {
-      this.store.clear();
-      this.conversations.clear();
-    }
-  }
-}

package/src/memory/seed-loader.ts

@@ -1,212 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-
-export interface BrainSeedConfig {
-  seeds: string[];
-  autoSeed: boolean;
-  seedMarkerFile?: string;
-  evolve?: {
-    enabled: boolean;
-    direction: 'bottom-up' | 'top-down';
-  };
-}
-
-export interface SeedPage {
-  slug: string;
-  content: string;
-  tier: string;
-}
-
-export interface SeedResult {
-  imported: number;
-  pages: string[];
-}
-
-export interface PromotionCandidate {
-  slug: string;
-  content: string;
-  fromTier: string;
-  toTier: string;
-  confidence: number;
-}
-
-export interface PromotionResult {
-  candidates: PromotionCandidate[];
-  promoted: number;
-}
-
-export class BrainSeedLoader {
-  private markerFile: string;
-
-  constructor(private agentDir: string, private config: BrainSeedConfig) {
-    this.markerFile = config.seedMarkerFile
-      ? path.resolve(agentDir, config.seedMarkerFile)
-      : path.resolve(agentDir, '.brain-seeded');
-  }
-
-  async isSeeded(): Promise<boolean> {
-    return fs.existsSync(this.markerFile);
-  }
-
-  async seedBrain(brain: any): Promise<SeedResult> {
-    const allPages: SeedPage[] = [];
-
-    for (const seedPath of this.config.seeds) {
-      const fullPath = path.resolve(this.agentDir, seedPath);
-      if (!fs.existsSync(fullPath)) continue;
-
-      const tier = this.inferTier(seedPath);
-      const pages = this.parseSeedFile(fullPath, tier);
-      allPages.push(...pages);
-    }
-
-    const importedSlugs: string[] = [];
-    for (const page of allPages) {
-      if (brain && typeof brain.store === 'function') {
-        await brain.store('brain-seeds', page.slug, page.content, {
-          tier: page.tier,
-          source: 'brain-seed',
-        });
-      } else if (brain && typeof brain.learn === 'function') {
-        await brain.learn(page.content, {
-          tags: ['brain-seed', page.tier],
-          slug: page.slug,
-        });
-      }
-      importedSlugs.push(page.slug);
-    }
-
-    return { imported: importedSlugs.length, pages: importedSlugs };
-  }
-
-  async markSeeded(): Promise<void> {
-    const dir = path.dirname(this.markerFile);
-    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-    fs.writeFileSync(this.markerFile, JSON.stringify({
-      seededAt: new Date().toISOString(),
-      seeds: this.config.seeds,
-    }, null, 2));
-  }
-
-  parseSeedFile(filePath: string, tier: string): SeedPage[] {
-    const content = fs.readFileSync(filePath, 'utf-8');
-    const pages: SeedPage[] = [];
-    const sections = content.split(/^## /m);
-
-    for (const section of sections) {
-      const trimmed = section.trim();
-      if (!trimmed) continue;
-
-      const newlineIdx = trimmed.indexOf('\n');
-      if (newlineIdx === -1 && sections.indexOf(section) === 0 && !content.trimStart().startsWith('## ')) {
-        // This is preamble before any ## heading — skip or treat as intro
-        continue;
-      }
-
-      let title: string;
-      let body: string;
-
-      if (sections.indexOf(section) === 0 && !content.trimStart().startsWith('## ')) {
-        // Preamble (before first ##)
-        continue;
-      }
-
-      if (newlineIdx === -1) {
-        title = trimmed;
-        body = '';
-      } else {
-        title = trimmed.slice(0, newlineIdx).trim();
-        body = trimmed.slice(newlineIdx + 1).trim();
-      }
-
-      const slug = `seed/${tier}/${this.slugify(title)}`;
-      pages.push({ slug, content: `## ${title}\n\n${body}`, tier });
-    }
-
-    return pages;
-  }
-
-  private inferTier(seedPath: string): string {
-    const basename = path.basename(seedPath, path.extname(seedPath)).toLowerCase();
-    if (basename.includes('industry')) return 'industry';
-    if (basename.includes('job')) return 'job';
-    if (basename.includes('workstation')) return 'workstation';
-    return 'workstation';
-  }
-
-  private slugify(text: string): string {
-    return text
-      .toLowerCase()
-      .replace(/[^a-z0-9\u4e00-\u9fff]+/g, '-')
-      .replace(/^-|-$/g, '');
-  }
-}
-
-export class KnowledgeEvolver {
-  private tierOrder = ['workstation', 'job', 'industry'];
-
-  async checkPromotion(brain: any, options: {
-    minInteractions?: number;
-    confidenceThreshold?: number;
-  } = {}): Promise<PromotionResult> {
-    const minInteractions = options.minInteractions ?? 50;
-    const confidenceThreshold = options.confidenceThreshold ?? 0.8;
-
-    const result: PromotionResult = { candidates: [], promoted: 0 };
-
-    // Search for frequently referenced seed knowledge
-    if (!brain || typeof brain.search !== 'function') return result;
-
-    try {
-      const seedPages = await brain.search('brain-seeds', 'seed/', 100);
-      if (!Array.isArray(seedPages)) return result;
-
-      for (const page of seedPages) {
-        const meta = page.metadata || {};
-        const usageCount = meta.usageCount ?? 0;
-        const tier = meta.tier || 'workstation';
-
-        if (usageCount < minInteractions) continue;
-
-        const confidence = Math.min(usageCount / (minInteractions * 2), 1.0);
-        if (confidence < confidenceThreshold) continue;
-
-        const tierIdx = this.tierOrder.indexOf(tier);
-        if (tierIdx <= 0) continue; // already at highest tier or unknown
-
-        const toTier = this.tierOrder[tierIdx - 1];
-        result.candidates.push({
-          slug: page.id || page.slug,
-          content: page.content,
-          fromTier: tier,
-          toTier,
-          confidence,
-        });
-      }
-    } catch {
-      // Silent fail
-    }
-
-    return result;
-  }
-
-  async promoteToJob(brain: any, knowledge: string, jobSlug: string): Promise<void> {
-    if (brain && typeof brain.store === 'function') {
-      await brain.store('brain-seeds', jobSlug, knowledge, {
-        tier: 'job',
-        source: 'promotion',
-        promotedAt: new Date().toISOString(),
-      });
-    }
-  }
-
-  async promoteToIndustry(brain: any, knowledge: string, industrySlug: string): Promise<void> {
-    if (brain && typeof brain.store === 'function') {
-      await brain.store('brain-seeds', industrySlug, knowledge, {
-        tier: 'industry',
-        source: 'promotion',
-        promotedAt: new Date().toISOString(),
-      });
-    }
-  }
-}