opc-agent 1.4.0 → 2.0.0

package/src/core/scheduler.ts

@@ -0,0 +1,187 @@
+/**
+ * Simple cron scheduler — no external dependencies.
+ * Supports cron expressions: star, star-slash-N, M-N, M,N for minute/hour/day/month/weekday.
+ */
+
+export interface CronJob {
+  id: string;
+  name: string;
+  schedule: string;
+  task: string;
+  enabled: boolean;
+  lastRun?: Date;
+  nextRun?: Date;
+}
+
+type CronField = { type: 'any' } | { type: 'every'; step: number } | { type: 'list'; values: number[] };
+
+interface ParsedCron {
+  minute: CronField;
+  hour: CronField;
+  dayOfMonth: CronField;
+  month: CronField;
+  dayOfWeek: CronField;
+}
+
+function parseField(field: string, min: number, max: number): CronField {
+  if (field === '*') return { type: 'any' };
+  if (field.startsWith('*/')) {
+    const step = parseInt(field.slice(2), 10);
+    if (isNaN(step) || step <= 0) throw new Error(`Invalid cron step: ${field}`);
+    return { type: 'every', step };
+  }
+  // Could be comma-separated, each part could be a range
+  const values: number[] = [];
+  for (const part of field.split(',')) {
+    if (part.includes('-')) {
+      const [a, b] = part.split('-').map(Number);
+      if (isNaN(a) || isNaN(b)) throw new Error(`Invalid cron range: ${part}`);
+      for (let i = a; i <= b; i++) values.push(i);
+    } else {
+      const n = parseInt(part, 10);
+      if (isNaN(n)) throw new Error(`Invalid cron value: ${part}`);
+      values.push(n);
+    }
+  }
+  return { type: 'list', values };
+}
+
+export function parseCron(expr: string): ParsedCron {
+  const parts = expr.trim().split(/\s+/);
+  if (parts.length !== 5) throw new Error(`Invalid cron expression (need 5 fields): ${expr}`);
+  return {
+    minute: parseField(parts[0], 0, 59),
+    hour: parseField(parts[1], 0, 23),
+    dayOfMonth: parseField(parts[2], 1, 31),
+    month: parseField(parts[3], 1, 12),
+    dayOfWeek: parseField(parts[4], 0, 6),
+  };
+}
+
+function fieldMatches(field: CronField, value: number): boolean {
+  switch (field.type) {
+    case 'any': return true;
+    case 'every': return value % field.step === 0;
+    case 'list': return field.values.includes(value);
+  }
+}
+
+export function cronMatches(parsed: ParsedCron, date: Date): boolean {
+  return (
+    fieldMatches(parsed.minute, date.getMinutes()) &&
+    fieldMatches(parsed.hour, date.getHours()) &&
+    fieldMatches(parsed.dayOfMonth, date.getDate()) &&
+    fieldMatches(parsed.month, date.getMonth() + 1) &&
+    fieldMatches(parsed.dayOfWeek, date.getDay())
+  );
+}
+
+/** Compute approximate next run (scans forward up to 48h). */
+function computeNextRun(parsed: ParsedCron, from: Date): Date | undefined {
+  const d = new Date(from);
+  d.setSeconds(0, 0);
+  d.setMinutes(d.getMinutes() + 1);
+  const limit = 48 * 60; // 48 hours in minutes
+  for (let i = 0; i < limit; i++) {
+    if (cronMatches(parsed, d)) return new Date(d);
+    d.setMinutes(d.getMinutes() + 1);
+  }
+  return undefined;
+}
+
+export type JobHandler = (job: CronJob) => void | Promise<void>;
+
+export class Scheduler {
+  private jobs = new Map<string, CronJob>();
+  private parsed = new Map<string, ParsedCron>();
+  private timer: ReturnType<typeof setInterval> | null = null;
+  private handler: JobHandler;
+
+  constructor(handler: JobHandler) {
+    this.handler = handler;
+  }
+
+  addJob(job: CronJob): void {
+    const p = parseCron(job.schedule);
+    this.parsed.set(job.id, p);
+    job.nextRun = computeNextRun(p, new Date()) ?? undefined;
+    this.jobs.set(job.id, job);
+  }
+
+  removeJob(id: string): void {
+    this.jobs.delete(id);
+    this.parsed.delete(id);
+  }
+
+  enableJob(id: string): void {
+    const job = this.jobs.get(id);
+    if (job) job.enabled = true;
+  }
+
+  disableJob(id: string): void {
+    const job = this.jobs.get(id);
+    if (job) job.enabled = false;
+  }
+
+  getJobs(): CronJob[] {
+    return Array.from(this.jobs.values());
+  }
+
+  getJob(id: string): CronJob | undefined {
+    return this.jobs.get(id);
+  }
+
+  /** Run a specific job immediately */
+  async runJob(id: string): Promise<boolean> {
+    const job = this.jobs.get(id);
+    if (!job) return false;
+    job.lastRun = new Date();
+    await this.handler(job);
+    const parsed = this.parsed.get(id);
+    if (parsed) job.nextRun = computeNextRun(parsed, new Date());
+    return true;
+  }
+
+  start(): void {
+    if (this.timer) return;
+    // Check every 60 seconds
+    this.timer = setInterval(() => this.tick(), 60_000);
+    // Also tick immediately
+    this.tick();
+  }
+
+  stop(): void {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+
+  private tick(): void {
+    const now = new Date();
+    for (const [id, job] of this.jobs) {
+      if (!job.enabled) continue;
+      const parsed = this.parsed.get(id);
+      if (!parsed) continue;
+      if (cronMatches(parsed, now)) {
+        // Avoid double-fire: check lastRun isn't same minute
+        if (job.lastRun) {
+          const last = job.lastRun;
+          if (last.getFullYear() === now.getFullYear() &&
+              last.getMonth() === now.getMonth() &&
+              last.getDate() === now.getDate() &&
+              last.getHours() === now.getHours() &&
+              last.getMinutes() === now.getMinutes()) {
+            continue;
+          }
+        }
+        job.lastRun = new Date(now);
+        job.nextRun = computeNextRun(parsed, now);
+        // Fire and forget (log errors)
+        Promise.resolve(this.handler(job)).catch((err) => {
+          console.error(`[scheduler] Job "${job.name}" failed:`, err);
+        });
+      }
+    }
+  }
+}

package/src/core/subagent.ts

@@ -0,0 +1,98 @@
+import { BaseAgent } from './agent';
+import { InMemoryStore } from '../memory';
+import type { Message } from './types';
+
+export interface SubAgentConfig {
+  name: string;
+  task: string;
+  systemPrompt?: string;
+  provider?: string;
+  model?: string;
+  timeout?: number;
+  isolated?: boolean;
+}
+
+export interface SubAgentResult {
+  id: string;
+  name: string;
+  status: 'completed' | 'failed' | 'timeout';
+  result: string;
+  duration: number;
+}
+
+interface SubAgentEntry {
+  agent: BaseAgent;
+  status: string;
+  name: string;
+}
+
+export class SubAgentManager {
+  private agents: Map<string, SubAgentEntry> = new Map();
+
+  async spawn(config: SubAgentConfig, parentProvider?: any): Promise<SubAgentResult> {
+    const id = `sub_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+    const timeout = config.timeout ?? 300000;
+    const isolated = config.isolated !== false;
+
+    const agent = new BaseAgent({
+      name: config.name,
+      systemPrompt: config.systemPrompt ?? 'You are a helpful sub-agent.',
+      provider: config.provider ?? 'openai',
+      model: config.model,
+      memory: isolated ? new InMemoryStore() : undefined,
+    });
+
+    this.agents.set(id, { agent, status: 'running', name: config.name });
+
+    const message: Message = {
+      id: `msg_${Date.now()}`,
+      role: 'user',
+      content: config.task,
+      timestamp: Date.now(),
+      metadata: { subAgentId: id },
+    };
+
+    const start = Date.now();
+
+    try {
+      const result = await Promise.race([
+        agent.handleMessage(message),
+        new Promise<never>((_, reject) =>
+          setTimeout(() => reject(new Error('SubAgent timeout')), timeout),
+        ),
+      ]);
+
+      const duration = Date.now() - start;
+      this.agents.set(id, { agent, status: 'completed', name: config.name });
+
+      return { id, name: config.name, status: 'completed', result: result.content, duration };
+    } catch (err) {
+      const duration = Date.now() - start;
+      const isTimeout = (err as Error).message.includes('timeout');
+      const status = isTimeout ? 'timeout' : 'failed';
+      this.agents.set(id, { agent, status, name: config.name });
+
+      return { id, name: config.name, status, result: (err as Error).message, duration };
+    }
+  }
+
+  async spawnParallel(configs: SubAgentConfig[], parentProvider?: any): Promise<SubAgentResult[]> {
+    return Promise.all(configs.map((c) => this.spawn(c, parentProvider)));
+  }
+
+  list(): Array<{ id: string; name: string; status: string }> {
+    return Array.from(this.agents.entries()).map(([id, entry]) => ({
+      id,
+      name: entry.name,
+      status: entry.status,
+    }));
+  }
+
+  kill(id: string): boolean {
+    const entry = this.agents.get(id);
+    if (!entry) return false;
+    entry.status = 'killed';
+    this.agents.set(id, entry);
+    return true;
+  }
+}

package/src/daemon.ts

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+/**
+ * Daemon entry point — spawned by `opc start` as a detached background process.
+ * Loads agent.yaml, creates runtime, starts all channels, writes heartbeat.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { AgentRuntime } from './core/runtime';
+
+const OPC_DIR = path.resolve('.opc');
+const HEARTBEAT_FILE = path.join(OPC_DIR, 'heartbeat');
+const LOG_FILE = path.join(OPC_DIR, 'agent.log');
+const PID_FILE = path.join(OPC_DIR, 'agent.pid');
+const HEARTBEAT_INTERVAL = 30_000;
+
+function ensureDir(dir: string) {
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+}
+
+function log(msg: string) {
+  const line = `[${new Date().toISOString()}] ${msg}\n`;
+  try { fs.appendFileSync(LOG_FILE, line); } catch { /* ignore */ }
+}
+
+async function main() {
+  ensureDir(OPC_DIR);
+
+  // Redirect stdout/stderr to log file
+  const logStream = fs.createWriteStream(LOG_FILE, { flags: 'a' });
+  process.stdout.write = logStream.write.bind(logStream) as any;
+  process.stderr.write = logStream.write.bind(logStream) as any;
+
+  // Write PID
+  fs.writeFileSync(PID_FILE, String(process.pid));
+  log(`Daemon started, PID=${process.pid}`);
+
+  // Write start time for uptime calculation
+  fs.writeFileSync(path.join(OPC_DIR, 'started'), String(Date.now()));
+
+  // Heartbeat
+  const heartbeatTimer = setInterval(() => {
+    try { fs.writeFileSync(HEARTBEAT_FILE, String(Date.now())); } catch { /* ignore */ }
+  }, HEARTBEAT_INTERVAL);
+  fs.writeFileSync(HEARTBEAT_FILE, String(Date.now()));
+
+  // Load .env
+  const envPath = path.resolve('.env');
+  if (fs.existsSync(envPath)) {
+    try {
+      const content = fs.readFileSync(envPath, 'utf-8');
+      for (const line of content.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#')) continue;
+        const eqIdx = trimmed.indexOf('=');
+        if (eqIdx === -1) continue;
+        const key = trimmed.slice(0, eqIdx).trim();
+        const value = trimmed.slice(eqIdx + 1).trim();
+        if (!process.env[key]) process.env[key] = value;
+      }
+    } catch { /* ignore */ }
+  }
+
+  // Determine config file
+  const configFile = fs.existsSync('agent.yaml') ? 'agent.yaml' : 'oad.yaml';
+
+  const runtime = new AgentRuntime();
+  await runtime.loadConfig(configFile);
+  await runtime.initialize();
+  await runtime.start();
+
+  log(`Agent running (config=${configFile})`);
+
+  // Graceful shutdown
+  const shutdown = async (signal: string) => {
+    log(`Received ${signal}, shutting down...`);
+    clearInterval(heartbeatTimer);
+    await runtime.stop();
+    try { fs.unlinkSync(PID_FILE); } catch { /* ignore */ }
+    log('Daemon stopped');
+    process.exit(0);
+  };
+
+  process.on('SIGTERM', () => shutdown('SIGTERM'));
+  process.on('SIGINT', () => shutdown('SIGINT'));
+
+  // On Windows, handle the message-based kill
+  process.on('message', (msg) => {
+    if (msg === 'shutdown') shutdown('message:shutdown');
+  });
+}
+
+main().catch((err) => {
+  log(`Fatal error: ${err instanceof Error ? err.message : String(err)}`);
+  try { fs.unlinkSync(PID_FILE); } catch { /* ignore */ }
+  process.exit(1);
+});

package/src/index.ts

@@ -76,6 +76,8 @@ export { SchedulerSkill } from './skills/scheduler';
 export type { ScheduledTask } from './skills/scheduler';
 export { DocumentSkill } from './skills/document';
 export type { DocumentChunk } from './skills/document';
+export { SkillLearner, skillToMarkdown, parseSkillMarkdown } from './skills/auto-learn';
+export type { LearnedSkill } from './skills/auto-learn';
 
 // v0.9.0 modules
 export { runTests, loadTestCases, formatReport } from './testing';
@@ -113,3 +115,12 @@ export type { StreamChunk, StreamOptions } from './core/streaming';
 // v1.3.0 modules
 export { TraceCollector, ConsoleExporter, DeepBrainExporter } from './traces';
 export type { Span, SpanEvent, TraceExporter } from './traces';
+
+// v1.4.0 modules
+export { Scheduler, parseCron, cronMatches } from './core/scheduler';
+export type { CronJob, JobHandler } from './core/scheduler';
+
+// v1.5.0 — built-in tools + MCP client
+export { getBuiltinTools, getBuiltinToolsByName } from './tools/builtin';
+export { MCPClient } from './tools/mcp-client';
+export type { MCPServerConfig } from './tools/mcp-client';