opc-agent 3.0.1 → 4.0.1

package/src/memory/context-compressor.ts

@@ -0,0 +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 [];
+    }
+  }
+}

package/src/memory/index.ts

@@ -2,6 +2,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 class InMemoryStore implements MemoryStore {
   private store: Map<string, unknown> = new Map();

package/src/memory/user-profiler.ts

@@ -0,0 +1,215 @@
+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/providers/index.ts

@@ -325,9 +325,72 @@ function isGeminiNative(): boolean {
   return key.startsWith('AQ.') || (baseUrl.includes('googleapis.com') && !baseUrl.includes('/openai'));
 }
 
+class ClaudeCLIProvider implements LLMProvider {
+  name = 'claude-cli';
+  private model: string;
+
+  constructor(model?: string) {
+    this.model = model || 'sonnet';
+  }
+
+  async chat(messages: Message[], systemPrompt?: string, options?: ChatOptions): Promise<string> {
+    const { execFile } = await import('child_process');
+    const { promisify } = await import('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: any) {
+      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: Message[], systemPrompt?: string): AsyncIterable<string> {
+    // Claude CLI --print doesn't support streaming well, so we do single-shot
+    const result = await this.chat(messages, systemPrompt);
+    yield result;
+  }
+}
+
 export function createProvider(name: string = 'openai', model?: string, baseUrl?: string, apiKey?: string): LLMProvider {
   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';
@@ -351,4 +414,4 @@ export function createProvider(name: string = 'openai', model?: string, baseUrl?
   return new OpenAICompatibleProvider(resolvedName, finalModel, baseUrl, apiKey);
 }
 
-export const SUPPORTED_PROVIDERS = ['openai', 'ollama', 'deepseek', 'qwen', 'gemini', 'dashscope', 'zhipu', 'moonshot'] as const;
+export const SUPPORTED_PROVIDERS = ['openai', 'ollama', 'claude-cli', 'deepseek', 'qwen', 'gemini', 'dashscope', 'zhipu', 'moonshot'] as const;

package/src/scheduler/cron-engine.ts

@@ -0,0 +1,191 @@
+/**
+ * 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 { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import * as os from 'os';
+import { parseCron, cronMatches, Scheduler } from '../core/scheduler';
+import type { CronJob, JobHandler } from '../core/scheduler';
+
+export interface ScheduleTask {
+  id: string;
+  name: string;
+  schedule: string;        // cron expression
+  description: string;     // natural language description
+  frequency: 'daily' | 'weekly' | 'monthly' | 'custom';
+  time?: string;           // HH:mm for simple schedules
+  outputChannel: 'telegram' | 'email' | 'web';
+  enabled: boolean;
+  createdAt: string;
+  updatedAt: string;
+  lastRun?: string;
+  nextRun?: string;
+}
+
+export interface SchedulesStore {
+  tasks: ScheduleTask[];
+}
+
+function getSchedulesPath(): string {
+  const dir = join(os.homedir(), '.opc');
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  return join(dir, 'schedules.json');
+}
+
+function loadSchedules(): SchedulesStore {
+  const p = getSchedulesPath();
+  if (existsSync(p)) {
+    try { return JSON.parse(readFileSync(p, 'utf-8')); } catch { /* ignore */ }
+  }
+  return { tasks: [] };
+}
+
+function saveSchedules(store: SchedulesStore): void {
+  writeFileSync(getSchedulesPath(), JSON.stringify(store, null, 2));
+}
+
+/** Convert frequency + time to cron expression */
+export function frequencyToCron(frequency: string, time?: string): string {
+  const [hour, minute] = (time || '09:00').split(':').map(Number);
+  switch (frequency) {
+    case 'daily':   return `${minute} ${hour} * * *`;
+    case 'weekly':  return `${minute} ${hour} * * 1`;
+    case 'monthly': return `${minute} ${hour} 1 * *`;
+    default:        return '0 9 * * *'; // fallback
+  }
+}
+
+/** Compute next run from a cron expression */
+function computeNextRun(cronExpr: string): string | undefined {
+  try {
+    const parsed = parseCron(cronExpr);
+    const d = new Date();
+    d.setSeconds(0, 0);
+    d.setMinutes(d.getMinutes() + 1);
+    for (let i = 0; i < 48 * 60; i++) {
+      if (cronMatches(parsed, d)) return d.toISOString();
+      d.setMinutes(d.getMinutes() + 1);
+    }
+  } catch { /* ignore */ }
+  return undefined;
+}
+
+export class CronEngine {
+  private scheduler: Scheduler;
+  private store: SchedulesStore;
+  private handler: JobHandler;
+
+  constructor(handler?: JobHandler) {
+    this.handler = handler || (async (job) => {
+      console.log(`[cron-engine] Executing job: ${job.name} (${job.id})`);
+    });
+    this.scheduler = new Scheduler(this.handler);
+    this.store = loadSchedules();
+  }
+
+  /** Initialize and recover persisted tasks */
+  start(): void {
+    for (const task of this.store.tasks) {
+      if (task.enabled) {
+        this.scheduler.addJob({
+          id: task.id,
+          name: task.name,
+          schedule: task.schedule,
+          task: task.description,
+          enabled: true,
+        });
+      }
+    }
+    this.scheduler.start();
+    console.log(`[cron-engine] Started with ${this.store.tasks.filter(t => t.enabled).length} active tasks`);
+  }
+
+  stop(): void {
+    this.scheduler.stop();
+  }
+
+  listTasks(): ScheduleTask[] {
+    // Refresh nextRun
+    return this.store.tasks.map(t => ({
+      ...t,
+      nextRun: t.enabled ? computeNextRun(t.schedule) : undefined,
+    }));
+  }
+
+  getTask(id: string): ScheduleTask | undefined {
+    return this.store.tasks.find(t => t.id === id);
+  }
+
+  createTask(input: Omit<ScheduleTask, 'id' | 'createdAt' | 'updatedAt' | 'lastRun' | 'nextRun'>): ScheduleTask {
+    const id = `sched-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+    const now = new Date().toISOString();
+    const schedule = input.schedule || frequencyToCron(input.frequency, input.time);
+    const task: ScheduleTask = {
+      ...input,
+      id,
+      schedule,
+      createdAt: now,
+      updatedAt: now,
+      nextRun: input.enabled ? computeNextRun(schedule) : undefined,
+    };
+    this.store.tasks.push(task);
+    saveSchedules(this.store);
+
+    if (task.enabled) {
+      this.scheduler.addJob({
+        id: task.id,
+        name: task.name,
+        schedule: task.schedule,
+        task: task.description,
+        enabled: true,
+      });
+    }
+    return task;
+  }
+
+  updateTask(id: string, updates: Partial<ScheduleTask>): ScheduleTask | null {
+    const idx = this.store.tasks.findIndex(t => t.id === id);
+    if (idx === -1) return null;
+
+    const task = { ...this.store.tasks[idx], ...updates, id, updatedAt: new Date().toISOString() };
+    if (updates.frequency || updates.time) {
+      task.schedule = updates.schedule || frequencyToCron(task.frequency, task.time);
+    }
+    task.nextRun = task.enabled ? computeNextRun(task.schedule) : undefined;
+    this.store.tasks[idx] = task;
+    saveSchedules(this.store);
+
+    // Update scheduler
+    this.scheduler.removeJob(id);
+    if (task.enabled) {
+      this.scheduler.addJob({
+        id: task.id,
+        name: task.name,
+        schedule: task.schedule,
+        task: task.description,
+        enabled: true,
+      });
+    }
+    return task;
+  }
+
+  deleteTask(id: string): boolean {
+    const idx = this.store.tasks.findIndex(t => t.id === id);
+    if (idx === -1) return false;
+    this.store.tasks.splice(idx, 1);
+    saveSchedules(this.store);
+    this.scheduler.removeJob(id);
+    return true;
+  }
+
+  async runTask(id: string): Promise<boolean> {
+    const task = this.store.tasks.find(t => t.id === id);
+    if (!task) return false;
+    task.lastRun = new Date().toISOString();
+    saveSchedules(this.store);
+    return this.scheduler.runJob(id);
+  }
+}

package/src/scheduler/index.ts

@@ -0,0 +1,2 @@
+export { CronEngine, frequencyToCron } from './cron-engine';
+export type { ScheduleTask, SchedulesStore } from './cron-engine';