opc-agent 3.0.1 → 4.0.1

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/providers/index.d.ts

@@ -9,5 +9,5 @@ export interface LLMProvider {
     chatStream(messages: Message[], systemPrompt?: string): AsyncIterable<string>;
 }
 export declare function createProvider(name?: string, model?: string, baseUrl?: string, apiKey?: string): LLMProvider;
-export declare const SUPPORTED_PROVIDERS: readonly ["openai", "ollama", "deepseek", "qwen", "gemini", "dashscope", "zhipu", "moonshot"];
+export declare const SUPPORTED_PROVIDERS: readonly ["openai", "ollama", "claude-cli", "deepseek", "qwen", "gemini", "dashscope", "zhipu", "moonshot"];
 //# sourceMappingURL=index.d.ts.map

package/dist/providers/index.js

@@ -323,8 +323,61 @@ function isGeminiNative() {
     const key = getApiKey();
     return key.startsWith('AQ.') || (baseUrl.includes('googleapis.com') && !baseUrl.includes('/openai'));
 }
+class ClaudeCLIProvider {
+    name = 'claude-cli';
+    model;
+    constructor(model) {
+        this.model = model || 'sonnet';
+    }
+    async chat(messages, systemPrompt, options) {
+        const { execFile } = await Promise.resolve().then(() => __importStar(require('child_process')));
+        const { promisify } = await Promise.resolve().then(() => __importStar(require('util')));
+        const execFileAsync = promisify(execFile);
+        // Build the prompt from messages
+        const lastMessage = messages[messages.length - 1];
+        if (!lastMessage)
+            return '';
+        let prompt = lastMessage.content;
+        // Add tool prompt if tools provided
+        if (options?.tools && options.tools.length > 0) {
+            prompt += buildToolPrompt(options.tools);
+        }
+        const args = ['--print'];
+        if (systemPrompt) {
+            args.push('--system-prompt', systemPrompt);
+        }
+        if (this.model) {
+            args.push('--model', this.model);
+        }
+        args.push(prompt);
+        try {
+            const { stdout } = await execFileAsync('claude', args, {
+                timeout: 120_000,
+                maxBuffer: 10 * 1024 * 1024,
+                env: { ...process.env },
+            });
+            return stdout.trim();
+        }
+        catch (err) {
+            if (err.code === 'ENOENT') {
+                throw new Error('Claude CLI not found. Install it: npm install -g @anthropic-ai/claude-code\n' +
+                    'Then authenticate: claude login');
+            }
+            throw new Error(`Claude CLI error: ${err.message}`);
+        }
+    }
+    async *chatStream(messages, systemPrompt) {
+        // Claude CLI --print doesn't support streaming well, so we do single-shot
+        const result = await this.chat(messages, systemPrompt);
+        yield result;
+    }
+}
 function createProvider(name = 'openai', model, baseUrl, apiKey) {
     const finalModel = model || process.env.OPC_LLM_MODEL || 'gpt-4o-mini';
+    // Claude CLI mode: use local claude command (Claude Max/Pro subscription)
+    if (name === 'claude-cli' || process.env.OPC_LLM_PROVIDER === 'claude-cli') {
+        return new ClaudeCLIProvider(finalModel !== 'gpt-4o-mini' ? finalModel : undefined);
+    }
     if (name === 'ollama') {
         const ollamaBase = baseUrl || process.env.OPC_LLM_BASE_URL || 'http://localhost:11434/v1';
         const ollamaKey = apiKey || process.env.OPC_LLM_API_KEY || 'ollama';
@@ -344,5 +397,5 @@ function createProvider(name = 'openai', model, baseUrl, apiKey) {
     }
     return new OpenAICompatibleProvider(resolvedName, finalModel, baseUrl, apiKey);
 }
-exports.SUPPORTED_PROVIDERS = ['openai', 'ollama', 'deepseek', 'qwen', 'gemini', 'dashscope', 'zhipu', 'moonshot'];
+exports.SUPPORTED_PROVIDERS = ['openai', 'ollama', 'claude-cli', 'deepseek', 'qwen', 'gemini', 'dashscope', 'zhipu', 'moonshot'];
 //# sourceMappingURL=index.js.map

package/dist/scheduler/cron-engine.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Cron Engine — persistent scheduler with file-based storage.
+ * Manages scheduled tasks with cron expressions, persists to ~/.opc/schedules.json,
+ * and auto-recovers on startup.
+ */
+import type { JobHandler } from '../core/scheduler';
+export interface ScheduleTask {
+    id: string;
+    name: string;
+    schedule: string;
+    description: string;
+    frequency: 'daily' | 'weekly' | 'monthly' | 'custom';
+    time?: string;
+    outputChannel: 'telegram' | 'email' | 'web';
+    enabled: boolean;
+    createdAt: string;
+    updatedAt: string;
+    lastRun?: string;
+    nextRun?: string;
+}
+export interface SchedulesStore {
+    tasks: ScheduleTask[];
+}
+/** Convert frequency + time to cron expression */
+export declare function frequencyToCron(frequency: string, time?: string): string;
+export declare class CronEngine {
+    private scheduler;
+    private store;
+    private handler;
+    constructor(handler?: JobHandler);
+    /** Initialize and recover persisted tasks */
+    start(): void;
+    stop(): void;
+    listTasks(): ScheduleTask[];
+    getTask(id: string): ScheduleTask | undefined;
+    createTask(input: Omit<ScheduleTask, 'id' | 'createdAt' | 'updatedAt' | 'lastRun' | 'nextRun'>): ScheduleTask;
+    updateTask(id: string, updates: Partial<ScheduleTask>): ScheduleTask | null;
+    deleteTask(id: string): boolean;
+    runTask(id: string): Promise<boolean>;
+}
+//# sourceMappingURL=cron-engine.d.ts.map