opc-agent 4.1.2 → 4.1.4

package/src/core/cache.ts

@@ -1,141 +0,0 @@
-/**
- * Caching Layer - Cache LLM responses with configurable TTL.
- * Hash-based key from input messages + system prompt.
- */
-import * as fs from 'fs';
-import * as path from 'path';
-import * as crypto from 'crypto';
-
-export interface CacheEntry {
-  key: string;
-  value: string;
-  createdAt: number;
-  ttlMs: number;
-  hits: number;
-}
-
-export interface CacheConfig {
-  enabled: boolean;
-  ttlMs: number; // default TTL
-  maxEntries: number;
-  dataDir: string;
-}
-
-export class LLMCache {
-  private cache: Map<string, CacheEntry> = new Map();
-  private config: CacheConfig;
-  private filePath: string;
-  private stats = { hits: 0, misses: 0, evictions: 0 };
-
-  constructor(config?: Partial<CacheConfig>) {
-    this.config = {
-      enabled: config?.enabled ?? true,
-      ttlMs: config?.ttlMs ?? 3600_000, // 1 hour default
-      maxEntries: config?.maxEntries ?? 1000,
-      dataDir: config?.dataDir ?? '.',
-    };
-    this.filePath = path.join(this.config.dataDir, 'data', 'cache.json');
-    this.load();
-  }
-
-  private load(): void {
-    try {
-      if (fs.existsSync(this.filePath)) {
-        const raw = fs.readFileSync(this.filePath, 'utf-8');
-        const entries: CacheEntry[] = JSON.parse(raw);
-        for (const entry of entries) {
-          if (!this.isExpired(entry)) {
-            this.cache.set(entry.key, entry);
-          }
-        }
-      }
-    } catch {
-      // ignore
-    }
-  }
-
-  private save(): void {
-    const dir = path.dirname(this.filePath);
-    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-    const entries = Array.from(this.cache.values());
-    fs.writeFileSync(this.filePath, JSON.stringify(entries));
-  }
-
-  private isExpired(entry: CacheEntry): boolean {
-    return Date.now() - entry.createdAt > entry.ttlMs;
-  }
-
-  /**
-   * Generate a cache key from messages and system prompt.
-   */
-  static makeKey(messages: Array<{ role: string; content: string }>, systemPrompt?: string): string {
-    const payload = JSON.stringify({ systemPrompt, messages: messages.map(m => ({ role: m.role, content: m.content })) });
-    return crypto.createHash('sha256').update(payload).digest('hex').slice(0, 16);
-  }
-
-  /**
-   * Get a cached response. Returns null if not found or expired.
-   */
-  get(key: string): string | null {
-    if (!this.config.enabled) return null;
-    const entry = this.cache.get(key);
-    if (!entry || this.isExpired(entry)) {
-      if (entry) {
-        this.cache.delete(key);
-        this.stats.evictions++;
-      }
-      this.stats.misses++;
-      return null;
-    }
-    entry.hits++;
-    this.stats.hits++;
-    return entry.value;
-  }
-
-  /**
-   * Set a cached response.
-   */
-  set(key: string, value: string, ttlMs?: number): void {
-    if (!this.config.enabled) return;
-
-    // Evict oldest if at capacity
-    if (this.cache.size >= this.config.maxEntries) {
-      let oldestKey: string | null = null;
-      let oldestTime = Infinity;
-      for (const [k, v] of this.cache) {
-        if (v.createdAt < oldestTime) {
-          oldestTime = v.createdAt;
-          oldestKey = k;
-        }
-      }
-      if (oldestKey) {
-        this.cache.delete(oldestKey);
-        this.stats.evictions++;
-      }
-    }
-
-    this.cache.set(key, {
-      key,
-      value,
-      createdAt: Date.now(),
-      ttlMs: ttlMs ?? this.config.ttlMs,
-      hits: 0,
-    });
-    this.save();
-  }
-
-  getStats(): { hits: number; misses: number; evictions: number; size: number; hitRate: string } {
-    const total = this.stats.hits + this.stats.misses;
-    return {
-      ...this.stats,
-      size: this.cache.size,
-      hitRate: total > 0 ? `${((this.stats.hits / total) * 100).toFixed(1)}%` : '0%',
-    };
-  }
-
-  clear(): void {
-    this.cache.clear();
-    this.stats = { hits: 0, misses: 0, evictions: 0 };
-    this.save();
-  }
-}

package/src/core/collaboration.ts

@@ -1,275 +0,0 @@
-/**
- * Multi-agent collaboration patterns
- * @module core/collaboration
- */
-
-import type { BaseAgent } from './agent';
-import type { Message } from './types';
-
-// ─── Result Types ───────────────────────────────────────────
-
-export interface DebateArgument {
-  agent: string;
-  round: number;
-  argument: string;
-}
-
-export interface DebateResult {
-  topic: string;
-  rounds: DebateArgument[];
-  summary: string;
-  judge?: string;
-}
-
-export interface VoteEntry {
-  agent: string;
-  choice: string;
-  confidence: number;
-}
-
-export interface VoteResult {
-  question: string;
-  votes: VoteEntry[];
-  winner: string;
-  tally: Record<string, number>;
-}
-
-export interface PipelineStageResult {
-  agent: string;
-  input: string;
-  output: string;
-  durationMs: number;
-}
-
-export interface PipelineResult {
-  stages: PipelineStageResult[];
-  finalOutput: string;
-  totalDurationMs: number;
-}
-
-export interface WorkerResult {
-  agent: string;
-  subtask: string;
-  result: string;
-}
-
-export interface HierarchyResult {
-  task: string;
-  subtasks: WorkerResult[];
-  synthesis: string;
-}
-
-// ─── Helper ─────────────────────────────────────────────────
-
-function makeMsg(role: 'user' | 'assistant' | 'system', content: string): Message {
-  return { id: `msg-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`, role, content, timestamp: Date.now() };
-}
-
-async function agentChat(agent: BaseAgent, prompt: string): Promise<string> {
-  const response = await agent.handleMessage(makeMsg('user', prompt));
-  return response.content;
-}
-
-// ─── DebatePattern ──────────────────────────────────────────
-
-export class DebatePattern {
-  constructor(private agents: BaseAgent[], private rounds: number = 3) {}
-
-  async debate(topic: string, judgeAgent?: BaseAgent): Promise<DebateResult> {
-    const allArgs: DebateArgument[] = [];
-    let context = '';
-
-    for (let round = 1; round <= this.rounds; round++) {
-      for (const agent of this.agents) {
-        const prompt = round === 1
-          ? `Debate topic: "${topic}". Present your argument.`
-          : `Debate topic: "${topic}". Previous arguments:\n${context}\nPresent your counter-argument for round ${round}.`;
-        const argument = await agentChat(agent, prompt);
-        allArgs.push({ agent: agent.name, round, argument });
-        context += `\n[${agent.name} round ${round}]: ${argument}`;
-      }
-    }
-
-    const judge = judgeAgent ?? this.agents[0];
-    const summaryPrompt = `You are the judge. Summarize and decide the winner of this debate on "${topic}":\n${context}`;
-    const summary = await agentChat(judge, summaryPrompt);
-
-    return { topic, rounds: allArgs, summary, judge: judge.name };
-  }
-}
-
-// ─── VotingPattern ──────────────────────────────────────────
-
-export class VotingPattern {
-  constructor(private agents: BaseAgent[]) {}
-
-  async vote(question: string, options: string[]): Promise<VoteResult> {
-    const votes: VoteEntry[] = [];
-    const optionList = options.map((o, i) => `${i + 1}. ${o}`).join('\n');
-
-    for (const agent of this.agents) {
-      const prompt = `Question: "${question}"\nOptions:\n${optionList}\nRespond with ONLY the exact text of your chosen option.`;
-      const raw = await agentChat(agent, prompt);
-      const choice = options.find(o => raw.includes(o)) ?? raw.trim();
-      votes.push({ agent: agent.name, choice, confidence: 1 });
-    }
-
-    return this.tallyVotes(question, votes);
-  }
-
-  async weightedVote(question: string, options: string[]): Promise<VoteResult> {
-    const votes: VoteEntry[] = [];
-    const optionList = options.map((o, i) => `${i + 1}. ${o}`).join('\n');
-
-    for (const agent of this.agents) {
-      const prompt = `Question: "${question}"\nOptions:\n${optionList}\nRespond in format: CHOICE|CONFIDENCE(0-1)`;
-      const raw = await agentChat(agent, prompt);
-      const parts = raw.split('|');
-      const choiceRaw = parts[0]?.trim() ?? '';
-      const choice = options.find(o => choiceRaw.includes(o)) ?? choiceRaw;
-      const confidence = Math.min(1, Math.max(0, parseFloat(parts[1] ?? '0.5') || 0.5));
-      votes.push({ agent: agent.name, choice, confidence });
-    }
-
-    return this.tallyVotes(question, votes);
-  }
-
-  private tallyVotes(question: string, votes: VoteEntry[]): VoteResult {
-    const tally: Record<string, number> = {};
-    for (const v of votes) {
-      tally[v.choice] = (tally[v.choice] ?? 0) + v.confidence;
-    }
-    const winner = Object.entries(tally).sort((a, b) => b[1] - a[1])[0]?.[0] ?? '';
-    return { question, votes, winner, tally };
-  }
-}
-
-// ─── PipelinePattern ────────────────────────────────────────
-
-export class PipelinePattern {
-  constructor(private stages: { agent: BaseAgent; transform?: (input: string) => string }[]) {}
-
-  async process(input: string): Promise<PipelineResult> {
-    const stageResults: PipelineStageResult[] = [];
-    let current = input;
-    const t0 = Date.now();
-
-    for (const stage of this.stages) {
-      const stageInput = stage.transform ? stage.transform(current) : current;
-      const start = Date.now();
-      const output = await agentChat(stage.agent, stageInput);
-      stageResults.push({ agent: stage.agent.name, input: stageInput, output, durationMs: Date.now() - start });
-      current = output;
-    }
-
-    return { stages: stageResults, finalOutput: current, totalDurationMs: Date.now() - t0 };
-  }
-}
-
-// ─── HierarchyPattern ───────────────────────────────────────
-
-export class HierarchyPattern {
-  constructor(private leader: BaseAgent, private workers: BaseAgent[]) {}
-
-  async execute(task: string): Promise<HierarchyResult> {
-    // Leader decomposes
-    const decomposePrompt = `Decompose this task into ${this.workers.length} subtasks (one per line, no numbering): "${task}"`;
-    const decomposition = await agentChat(this.leader, decomposePrompt);
-    const subtasks = decomposition.split('\n').map(s => s.trim()).filter(Boolean);
-
-    // Workers execute in parallel
-    const workerResults: WorkerResult[] = await Promise.all(
-      this.workers.map(async (worker, i) => {
-        const subtask = subtasks[i] ?? subtasks[subtasks.length - 1] ?? task;
-        const result = await agentChat(worker, `Complete this subtask: "${subtask}"`);
-        return { agent: worker.name, subtask, result };
-      })
-    );
-
-    // Leader synthesizes
-    const synthPrompt = `Original task: "${task}"\nSubtask results:\n${workerResults.map(r => `[${r.agent}] ${r.subtask}: ${r.result}`).join('\n')}\nSynthesize a final answer.`;
-    const synthesis = await agentChat(this.leader, synthPrompt);
-
-    return { task, subtasks: workerResults, synthesis };
-  }
-}
-
-// ─── SharedContext ───────────────────────────────────────────
-
-export class SharedContext {
-  private store: Map<string, any> = new Map();
-  private listeners: Map<string, ((value: any) => void)[]> = new Map();
-
-  set(key: string, value: any): void {
-    this.store.set(key, value);
-    const cbs = this.listeners.get(key);
-    if (cbs) cbs.forEach(cb => cb(value));
-  }
-
-  get<T>(key: string): T | undefined {
-    return this.store.get(key) as T | undefined;
-  }
-
-  getAll(): Record<string, any> {
-    const result: Record<string, any> = {};
-    for (const [k, v] of this.store) result[k] = v;
-    return result;
-  }
-
-  onChange(key: string, callback: (value: any) => void): void {
-    const existing = this.listeners.get(key) ?? [];
-    existing.push(callback);
-    this.listeners.set(key, existing);
-  }
-}
-
-// ─── ConversationProtocol ───────────────────────────────────
-
-export class ConversationProtocol {
-  async roundRobin(agents: BaseAgent[], topic: string, rounds: number): Promise<Message[]> {
-    const messages: Message[] = [];
-    let context = `Topic: "${topic}"`;
-
-    for (let round = 0; round < rounds; round++) {
-      for (const agent of agents) {
-        const prompt = `${context}\n\nIt's your turn to contribute to this discussion. Be concise.`;
-        const content = await agentChat(agent, prompt);
-        const msg = makeMsg('assistant', content);
-        (msg as any).agent = agent.name;
-        messages.push(msg);
-        context += `\n[${agent.name}]: ${content}`;
-      }
-    }
-
-    return messages;
-  }
-
-  async moderated(agents: BaseAgent[], moderator: BaseAgent, topic: string): Promise<Message[]> {
-    const messages: Message[] = [];
-    let context = `Topic: "${topic}"`;
-
-    // Moderator opens
-    const opening = await agentChat(moderator, `You are moderating a discussion on "${topic}". Introduce the topic and ask the first question.`);
-    const openMsg = makeMsg('assistant', opening);
-    (openMsg as any).agent = moderator.name;
-    messages.push(openMsg);
-    context += `\n[Moderator ${moderator.name}]: ${opening}`;
-
-    // Each agent responds
-    for (const agent of agents) {
-      const content = await agentChat(agent, `${context}\n\nRespond to the moderator's question.`);
-      const msg = makeMsg('assistant', content);
-      (msg as any).agent = agent.name;
-      messages.push(msg);
-      context += `\n[${agent.name}]: ${content}`;
-    }
-
-    // Moderator summarizes
-    const summary = await agentChat(moderator, `${context}\n\nSummarize the discussion and provide closing remarks.`);
-    const closeMsg = makeMsg('assistant', summary);
-    (closeMsg as any).agent = moderator.name;
-    messages.push(closeMsg);
-
-    return messages;
-  }
-}

package/src/core/compose.ts

@@ -1,77 +0,0 @@
-import type { AgentContext, Message } from './types';
-
-/**
- * Agent Composition — v0.8.0
- * Combine multiple agents into a pipeline: Agent A output → Agent B input.
- * Configurable in OAD: `compose: [agent-a, agent-b]`
- */
-
-export type AgentHandler = (context: AgentContext, message: Message) => Promise<Message>;
-
-export interface ComposableAgent {
-  id: string;
-  name: string;
-  handler: AgentHandler;
-}
-
-export interface ComposeOptions {
-  /** Stop pipeline if any agent returns empty content */
-  stopOnEmpty?: boolean;
-  /** Transform output between agents */
-  transform?: (output: Message, nextAgentId: string) => Message;
-  /** Timeout per agent in ms */
-  timeoutMs?: number;
-}
-
-export class AgentPipeline {
-  private agents: ComposableAgent[] = [];
-  private options: ComposeOptions;
-
-  constructor(agents: ComposableAgent[], options: ComposeOptions = {}) {
-    this.agents = agents;
-    this.options = options;
-  }
-
-  /** Run the pipeline sequentially: each agent's output becomes the next agent's input */
-  async execute(context: AgentContext, initialMessage: Message): Promise<Message> {
-    let currentMessage = initialMessage;
-
-    for (const agent of this.agents) {
-      if (this.options.stopOnEmpty && !currentMessage.content.trim()) {
-        break;
-      }
-
-      // Apply transform if provided
-      if (this.options.transform) {
-        currentMessage = this.options.transform(currentMessage, agent.id);
-      }
-
-      if (this.options.timeoutMs) {
-        const result = await Promise.race([
-          agent.handler(context, currentMessage),
-          new Promise<never>((_, reject) =>
-            setTimeout(() => reject(new Error(`Agent ${agent.id} timed out`)), this.options.timeoutMs)
-          ),
-        ]);
-        currentMessage = result;
-      } else {
-        currentMessage = await agent.handler(context, currentMessage);
-      }
-    }
-
-    return currentMessage;
-  }
-
-  /** Get the pipeline agent IDs in order */
-  getAgentIds(): string[] {
-    return this.agents.map((a) => a.id);
-  }
-}
-
-/**
- * Create a pipeline from an array of composable agents.
- * Usage in OAD: `compose: [agent-a, agent-b, agent-c]`
- */
-export function compose(agents: ComposableAgent[], options?: ComposeOptions): AgentPipeline {
-  return new AgentPipeline(agents, options);
-}

package/src/core/config.ts

@@ -1,14 +0,0 @@
-import * as fs from 'fs';
-import * as yaml from 'js-yaml';
-import { OADSchema, type OADDocument } from '../schema/oad';
-
-export function loadOAD(filePath: string): OADDocument {
-  const raw = fs.readFileSync(filePath, 'utf-8');
-  const ext = filePath.split('.').pop()?.toLowerCase();
-  const data = (ext === 'yaml' || ext === 'yml') ? yaml.load(raw) : JSON.parse(raw);
-  return OADSchema.parse(data);
-}
-
-export function validateOAD(data: unknown): OADDocument {
-  return OADSchema.parse(data);
-}

package/src/core/context-discovery.ts

@@ -1,85 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-
-export interface ContextFile {
-  path: string;
-  type: 'agents' | 'soul' | 'user' | 'memory' | 'tools' | 'identity' | 'heartbeat' | 'bootstrap' | 'custom';
-  content: string;
-}
-
-const FILE_TYPE_MAP: Record<string, ContextFile['type']> = {
-  'AGENTS.md': 'agents',
-  'SOUL.md': 'soul',
-  'USER.md': 'user',
-  'MEMORY.md': 'memory',
-  'TOOLS.md': 'tools',
-  'IDENTITY.md': 'identity',
-  'HEARTBEAT.md': 'heartbeat',
-  'BOOTSTRAP.md': 'bootstrap',
-  '.opc.md': 'custom',
-  '.opc/config.md': 'custom',
-};
-
-export class ContextDiscovery {
-  static STANDARD_FILES = [
-    'AGENTS.md', 'SOUL.md', 'USER.md', 'MEMORY.md', 'TOOLS.md',
-    'IDENTITY.md', 'HEARTBEAT.md', 'BOOTSTRAP.md',
-    '.opc.md', '.opc/config.md',
-  ];
-
-  private customFiles: string[] = [];
-  private watchers: fs.FSWatcher[] = [];
-
-  discover(workDir?: string): ContextFile[] {
-    const dir = workDir || process.cwd();
-    const found: ContextFile[] = [];
-
-    for (const file of ContextDiscovery.STANDARD_FILES) {
-      const fullPath = path.join(dir, file);
-      if (fs.existsSync(fullPath)) {
-        found.push({
-          path: fullPath,
-          type: FILE_TYPE_MAP[file] || 'custom',
-          content: fs.readFileSync(fullPath, 'utf-8'),
-        });
-      }
-    }
-
-    for (const file of this.customFiles) {
-      const fullPath = path.isAbsolute(file) ? file : path.join(dir, file);
-      if (fs.existsSync(fullPath)) {
-        found.push({
-          path: fullPath,
-          type: 'custom',
-          content: fs.readFileSync(fullPath, 'utf-8'),
-        });
-      }
-    }
-
-    return found;
-  }
-
-  load(files: ContextFile[]): string {
-    return files.map(f => `# ${f.type.toUpperCase()}\n${f.content}`).join('\n\n');
-  }
-
-  watch(workDir: string, onChange: Function): void {
-    const watcher = fs.watch(workDir, { recursive: false }, (event, filename) => {
-      if (filename && ContextDiscovery.STANDARD_FILES.includes(filename)) {
-        onChange(filename, event);
-      }
-    });
-    this.watchers.push(watcher);
-  }
-
-  stopWatching(): void {
-    for (const w of this.watchers) w.close();
-    this.watchers = [];
-  }
-
-  addCustomFile(filePath: string): void {
-    if (!this.customFiles.includes(filePath)) {
-      this.customFiles.push(filePath);
-    }
-  }
-}