opc-agent 3.0.1 → 4.0.0

package/dist/memory/context-compressor.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContextCompressor = void 0;
+const DEFAULT_CONFIG = {
+    maxTokens: 8000,
+    compressThreshold: 0.8,
+    preserveRecent: 10,
+};
+/**
+ * Context compression with optional DeepBrain memory offloading.
+ */
+class ContextCompressor {
+    config;
+    constructor(config = {}) {
+        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) {
+        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);
+    }
+    estimateMessagesTokens(messages) {
+        return messages.reduce((sum, m) => sum + this.estimateTokens(m.content), 0);
+    }
+    /**
+     * Extract key insights from messages for brain storage.
+     */
+    extractInsights(messages) {
+        const insights = [];
+        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).
+     */
+    summarize(messages) {
+        const topics = new Set();
+        const keyLines = [];
+        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, config) {
+        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;
+        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 = {
+            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, brain) {
+        if (!brain?.recall)
+            return [];
+        try {
+            const results = await brain.recall(query);
+            if (Array.isArray(results)) {
+                return results.map((r) => typeof r === 'string' ? r : r.content ?? JSON.stringify(r));
+            }
+            if (typeof results === 'string')
+                return [results];
+            return [];
+        }
+        catch {
+            return [];
+        }
+    }
+}
+exports.ContextCompressor = ContextCompressor;
+//# sourceMappingURL=context-compressor.js.map

package/dist/memory/index.d.ts

@@ -1,6 +1,10 @@
 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 declare class InMemoryStore implements MemoryStore {
     private store;
     private conversations;

package/dist/memory/index.js

@@ -1,9 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.InMemoryStore = exports.KnowledgeEvolver = exports.BrainSeedLoader = void 0;
+exports.InMemoryStore = exports.UserProfiler = exports.ContextCompressor = exports.KnowledgeEvolver = exports.BrainSeedLoader = void 0;
 var seed_loader_1 = require("./seed-loader");
 Object.defineProperty(exports, "BrainSeedLoader", { enumerable: true, get: function () { return seed_loader_1.BrainSeedLoader; } });
 Object.defineProperty(exports, "KnowledgeEvolver", { enumerable: true, get: function () { return seed_loader_1.KnowledgeEvolver; } });
+var context_compressor_1 = require("./context-compressor");
+Object.defineProperty(exports, "ContextCompressor", { enumerable: true, get: function () { return context_compressor_1.ContextCompressor; } });
+var user_profiler_1 = require("./user-profiler");
+Object.defineProperty(exports, "UserProfiler", { enumerable: true, get: function () { return user_profiler_1.UserProfiler; } });
 class InMemoryStore {
     store = new Map();
     conversations = new Map();

package/dist/memory/user-profiler.d.ts

@@ -0,0 +1,50 @@
+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;
+}
+/**
+ * DeepBrain-powered user profiling from conversation signals.
+ */
+export declare class UserProfiler {
+    private observationCount;
+    private signals;
+    private readonly LEARN_INTERVAL;
+    /**
+     * Detect language mix of a text.
+     */
+    private detectLanguage;
+    /**
+     * Detect technical level from content.
+     */
+    private detectTechLevel;
+    /**
+     * Detect communication style.
+     */
+    private detectStyle;
+    /**
+     * Extract domain keywords.
+     */
+    private extractDomainKeywords;
+    /**
+     * Classify request type.
+     */
+    private classifyRequest;
+    /**
+     * Observe a user message and accumulate profile signals.
+     */
+    observe(message: Message, brain?: any): Promise<void>;
+    private buildProfileFromSignals;
+    /**
+     * Get user profile, optionally from brain recall.
+     */
+    getProfile(brain?: any): Promise<UserProfile>;
+    /**
+     * Enhance a system prompt with user profile context.
+     */
+    enhance(systemPrompt: string, profile: UserProfile): string;
+}
+//# sourceMappingURL=user-profiler.d.ts.map

package/dist/memory/user-profiler.js

@@ -0,0 +1,201 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserProfiler = void 0;
+const EMPTY_PROFILE = {
+    preferences: {},
+    communication_style: 'unknown',
+    expertise_areas: [],
+    common_requests: [],
+    last_updated: 0,
+};
+/**
+ * DeepBrain-powered user profiling from conversation signals.
+ */
+class UserProfiler {
+    observationCount = 0;
+    signals = {
+        languages: new Map(),
+        techKeywords: new Set(),
+        styleSignals: { brief: 0, detailed: 0, formal: 0, casual: 0 },
+        requestTypes: new Map(),
+    };
+    LEARN_INTERVAL = 20;
+    /**
+     * Detect language mix of a text.
+     */
+    detectLanguage(text) {
+        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.
+     */
+    detectTechLevel(text) {
+        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.
+     */
+    detectStyle(text) {
+        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.
+     */
+    extractDomainKeywords(text) {
+        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.
+     */
+    classifyRequest(text) {
+        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, brain) {
+        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 */ }
+        }
+    }
+    buildProfileFromSignals() {
+        // 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],
+        ];
+        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) {
+        // 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, profile) {
+        const hints = [];
+        if (profile.preferences.language) {
+            const langMap = {
+                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(' ')}`;
+    }
+}
+exports.UserProfiler = UserProfiler;
+//# sourceMappingURL=user-profiler.js.map

package/dist/schema/oad.d.ts

@@ -39,14 +39,14 @@ export declare const VoiceSchema: z.ZodObject<{
     language: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     enabled: boolean;
+    language?: string | undefined;
     sttProvider?: string | undefined;
     ttsProvider?: string | undefined;
-    language?: string | undefined;
 }, {
+    language?: string | undefined;
     enabled?: boolean | undefined;
     sttProvider?: string | undefined;
     ttsProvider?: string | undefined;
-    language?: string | undefined;
 }>;
 export declare const WebhookSchema: z.ZodObject<{
     path: z.ZodOptional<z.ZodString>;
@@ -827,14 +827,14 @@ export declare const SpecSchema: z.ZodObject<{
         language: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
         enabled: boolean;
+        language?: string | undefined;
         sttProvider?: string | undefined;
         ttsProvider?: string | undefined;
-        language?: string | undefined;
     }, {
+        language?: string | undefined;
         enabled?: boolean | undefined;
         sttProvider?: string | undefined;
         ttsProvider?: string | undefined;
-        language?: string | undefined;
     }>>;
     webhook: z.ZodOptional<z.ZodObject<{
         path: z.ZodOptional<z.ZodString>;
@@ -1071,9 +1071,9 @@ export declare const SpecSchema: z.ZodObject<{
     } | undefined;
     voice?: {
         enabled: boolean;
+        language?: string | undefined;
         sttProvider?: string | undefined;
         ttsProvider?: string | undefined;
-        language?: string | undefined;
     } | undefined;
     webhook?: {
         path?: string | undefined;
@@ -1185,10 +1185,10 @@ export declare const SpecSchema: z.ZodObject<{
         sessionIsolation?: boolean | undefined;
     } | undefined;
     voice?: {
+        language?: string | undefined;
         enabled?: boolean | undefined;
         sttProvider?: string | undefined;
         ttsProvider?: string | undefined;
-        language?: string | undefined;
     } | undefined;
     webhook?: {
         path?: string | undefined;
@@ -1573,14 +1573,14 @@ export declare const OADSchema: z.ZodObject<{
             language: z.ZodOptional<z.ZodString>;
         }, "strip", z.ZodTypeAny, {
             enabled: boolean;
+            language?: string | undefined;
             sttProvider?: string | undefined;
             ttsProvider?: string | undefined;
-            language?: string | undefined;
         }, {
+            language?: string | undefined;
             enabled?: boolean | undefined;
             sttProvider?: string | undefined;
             ttsProvider?: string | undefined;
-            language?: string | undefined;
         }>>;
         webhook: z.ZodOptional<z.ZodObject<{
             path: z.ZodOptional<z.ZodString>;
@@ -1817,9 +1817,9 @@ export declare const OADSchema: z.ZodObject<{
         } | undefined;
         voice?: {
             enabled: boolean;
+            language?: string | undefined;
             sttProvider?: string | undefined;
             ttsProvider?: string | undefined;
-            language?: string | undefined;
         } | undefined;
         webhook?: {
             path?: string | undefined;
@@ -1931,10 +1931,10 @@ export declare const OADSchema: z.ZodObject<{
             sessionIsolation?: boolean | undefined;
         } | undefined;
         voice?: {
+            language?: string | undefined;
             enabled?: boolean | undefined;
             sttProvider?: string | undefined;
             ttsProvider?: string | undefined;
-            language?: string | undefined;
         } | undefined;
         webhook?: {
             path?: string | undefined;
@@ -2092,9 +2092,9 @@ export declare const OADSchema: z.ZodObject<{
         } | undefined;
         voice?: {
             enabled: boolean;
+            language?: string | undefined;
             sttProvider?: string | undefined;
             ttsProvider?: string | undefined;
-            language?: string | undefined;
         } | undefined;
         webhook?: {
             path?: string | undefined;
@@ -2223,10 +2223,10 @@ export declare const OADSchema: z.ZodObject<{
             sessionIsolation?: boolean | undefined;
         } | undefined;
         voice?: {
+            language?: string | undefined;
             enabled?: boolean | undefined;
             sttProvider?: string | undefined;
             ttsProvider?: string | undefined;
-            language?: string | undefined;
         } | undefined;
         webhook?: {
             path?: string | undefined;

package/dist/security/approvals.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Approvals Module - v1.0.0
+ * Policy-based exec approval system with queue, expiry, history, and callbacks.
+ */
+export type ExecApprovalPolicy = 'always' | 'elevated-only' | 'never' | 'allowlist';
+export interface ExecApprovalRequest {
+    id: string;
+    command: string;
+    elevated: boolean;
+    requestedAt: number;
+    expiresAt: number;
+    status: 'pending' | 'approved' | 'denied' | 'expired';
+    approvedBy?: string;
+    reason?: string;
+}
+export interface ExecApprovalHistory {
+    request: ExecApprovalRequest;
+    resolvedAt: number;
+}
+export type ApprovalRequestCallback = (request: ExecApprovalRequest) => void;
+export declare class ExecApprovalManager {
+    private policy;
+    private pending;
+    private history;
+    private allowedCommands;
+    private expiryMs;
+    private onRequestCallback?;
+    private expiryTimer?;
+    constructor(options?: {
+        policy?: ExecApprovalPolicy;
+        expiryMs?: number;
+        allowedCommands?: string[];
+        onRequest?: ApprovalRequestCallback;
+    });
+    getPolicy(): ExecApprovalPolicy;
+    setPolicy(p: ExecApprovalPolicy): void;
+    addAllowedCommand(cmd: string): void;
+    removeAllowedCommand(cmd: string): void;
+    getAllowedCommands(): string[];
+    needsApproval(command: string, elevated: boolean): boolean;
+    private isAllowed;
+    request(command: string, elevated?: boolean): ExecApprovalRequest;
+    approve(id: string, approver: string): ExecApprovalRequest;
+    deny(id: string, approver: string, reason?: string): ExecApprovalRequest;
+    getPending(): ExecApprovalRequest[];
+    getHistory(): ExecApprovalHistory[];
+    getRequest(id: string): ExecApprovalRequest | undefined;
+    private expirePending;
+    /** Force expire check (for testing) */
+    checkExpiry(): void;
+    destroy(): void;
+}
+//# sourceMappingURL=approvals.d.ts.map