opc-agent 1.1.1 → 1.1.2

package/src/skills/base.ts

@@ -1,16 +1,16 @@
-import type { ISkill, AgentContext, Message, SkillResult } from '../core/types';
-
-export abstract class BaseSkill implements ISkill {
-  abstract name: string;
-  abstract description: string;
-
-  abstract execute(context: AgentContext, message: Message): Promise<SkillResult>;
-
-  protected noMatch(): SkillResult {
-    return { handled: false, confidence: 0 };
-  }
-
-  protected match(response: string, confidence: number = 1.0): SkillResult {
-    return { handled: true, response, confidence };
-  }
-}
+import type { ISkill, AgentContext, Message, SkillResult } from '../core/types';
+
+export abstract class BaseSkill implements ISkill {
+  abstract name: string;
+  abstract description: string;
+
+  abstract execute(context: AgentContext, message: Message): Promise<SkillResult>;
+
+  protected noMatch(): SkillResult {
+    return { handled: false, confidence: 0 };
+  }
+
+  protected match(response: string, confidence: number = 1.0): SkillResult {
+    return { handled: true, response, confidence };
+  }
+}

package/src/skills/document.ts

@@ -1,100 +1,100 @@
-import { BaseSkill } from './base';
-import type { AgentContext, Message, SkillResult } from '../core/types';
-import { KnowledgeBase } from '../core/knowledge';
-
-export interface DocumentChunk {
-  content: string;
-  metadata: {
-    filename: string;
-    mimeType: string;
-    chunkIndex: number;
-    totalChunks: number;
-  };
-}
-
-export class DocumentSkill extends BaseSkill {
-  name = 'document';
-  description = 'Process uploaded documents (PDF, TXT, MD, DOCX). Chunks content and adds to knowledge base.';
-  private knowledgeBase: KnowledgeBase;
-
-  constructor(kbPath: string = '.') {
-    super();
-    this.knowledgeBase = new KnowledgeBase(kbPath);
-  }
-
-  async execute(context: AgentContext, message: Message): Promise<SkillResult> {
-    // Check if message has document attachment metadata
-    const meta = message.metadata;
-    if (!meta?.document) return this.noMatch();
-
-    const { content, filename, mimeType } = meta.document as {
-      content: string; filename: string; mimeType: string;
-    };
-
-    try {
-      const text = this.extractText(content, mimeType ?? this.guessMime(filename));
-      const chunks = this.chunk(text, 1000, 100);
-
-      const result = await this.knowledgeBase.addText(
-        chunks.map(c => c.content).join('\n\n---\n\n'),
-        filename
-      );
-
-      return this.match(
-        `📄 Processed "${filename}": ${chunks.length} chunks, ${text.length} chars → added to knowledge base (${result.chunks} KB entries)`
-      );
-    } catch (err) {
-      return this.match(`Document processing error: ${err instanceof Error ? err.message : String(err)}`);
-    }
-  }
-
-  extractText(content: string, mimeType: string): string {
-    // For plain text formats, content is already text
-    if (mimeType.includes('text/') || mimeType.includes('markdown')) {
-      return content;
-    }
-    // For other formats, assume base64-encoded or pre-extracted text
-    // In a real implementation, you'd use pdf-parse, mammoth, etc.
-    return content;
-  }
-
-  chunk(text: string, size: number = 1000, overlap: number = 100): DocumentChunk[] {
-    const chunks: DocumentChunk[] = [];
-    let start = 0;
-    while (start < text.length) {
-      const end = Math.min(start + size, text.length);
-      chunks.push({
-        content: text.slice(start, end),
-        metadata: {
-          filename: '',
-          mimeType: '',
-          chunkIndex: chunks.length,
-          totalChunks: 0, // filled after
-        },
-      });
-      start = end - overlap;
-      if (start >= text.length) break;
-    }
-    // Fill totalChunks
-    for (const c of chunks) c.metadata.totalChunks = chunks.length;
-    return chunks;
-  }
-
-  private guessMime(filename: string): string {
-    const ext = filename.split('.').pop()?.toLowerCase();
-    switch (ext) {
-      case 'pdf': return 'application/pdf';
-      case 'txt': return 'text/plain';
-      case 'md': return 'text/markdown';
-      case 'docx': return 'application/vnd.openxmlformats-officedocument.wordprocessingml.document';
-      default: return 'text/plain';
-    }
-  }
-
-  /** Process raw text content directly (for API uploads) */
-  async processText(content: string, filename: string): Promise<{ chunks: number; chars: number }> {
-    const chunks = this.chunk(content);
-    const result = await this.knowledgeBase.addText(content, filename);
-    return { chunks: chunks.length, chars: content.length };
-  }
-}
+import { BaseSkill } from './base';
+import type { AgentContext, Message, SkillResult } from '../core/types';
+import { KnowledgeBase } from '../core/knowledge';
+
+export interface DocumentChunk {
+  content: string;
+  metadata: {
+    filename: string;
+    mimeType: string;
+    chunkIndex: number;
+    totalChunks: number;
+  };
+}
+
+export class DocumentSkill extends BaseSkill {
+  name = 'document';
+  description = 'Process uploaded documents (PDF, TXT, MD, DOCX). Chunks content and adds to knowledge base.';
+  private knowledgeBase: KnowledgeBase;
+
+  constructor(kbPath: string = '.') {
+    super();
+    this.knowledgeBase = new KnowledgeBase(kbPath);
+  }
+
+  async execute(context: AgentContext, message: Message): Promise<SkillResult> {
+    // Check if message has document attachment metadata
+    const meta = message.metadata;
+    if (!meta?.document) return this.noMatch();
+
+    const { content, filename, mimeType } = meta.document as {
+      content: string; filename: string; mimeType: string;
+    };
+
+    try {
+      const text = this.extractText(content, mimeType ?? this.guessMime(filename));
+      const chunks = this.chunk(text, 1000, 100);
+
+      const result = await this.knowledgeBase.addText(
+        chunks.map(c => c.content).join('\n\n---\n\n'),
+        filename
+      );
+
+      return this.match(
+        `📄 Processed "${filename}": ${chunks.length} chunks, ${text.length} chars → added to knowledge base (${result.chunks} KB entries)`
+      );
+    } catch (err) {
+      return this.match(`Document processing error: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+
+  extractText(content: string, mimeType: string): string {
+    // For plain text formats, content is already text
+    if (mimeType.includes('text/') || mimeType.includes('markdown')) {
+      return content;
+    }
+    // For other formats, assume base64-encoded or pre-extracted text
+    // In a real implementation, you'd use pdf-parse, mammoth, etc.
+    return content;
+  }
+
+  chunk(text: string, size: number = 1000, overlap: number = 100): DocumentChunk[] {
+    const chunks: DocumentChunk[] = [];
+    let start = 0;
+    while (start < text.length) {
+      const end = Math.min(start + size, text.length);
+      chunks.push({
+        content: text.slice(start, end),
+        metadata: {
+          filename: '',
+          mimeType: '',
+          chunkIndex: chunks.length,
+          totalChunks: 0, // filled after
+        },
+      });
+      start = end - overlap;
+      if (start >= text.length) break;
+    }
+    // Fill totalChunks
+    for (const c of chunks) c.metadata.totalChunks = chunks.length;
+    return chunks;
+  }
+
+  private guessMime(filename: string): string {
+    const ext = filename.split('.').pop()?.toLowerCase();
+    switch (ext) {
+      case 'pdf': return 'application/pdf';
+      case 'txt': return 'text/plain';
+      case 'md': return 'text/markdown';
+      case 'docx': return 'application/vnd.openxmlformats-officedocument.wordprocessingml.document';
+      default: return 'text/plain';
+    }
+  }
+
+  /** Process raw text content directly (for API uploads) */
+  async processText(content: string, filename: string): Promise<{ chunks: number; chars: number }> {
+    const chunks = this.chunk(content);
+    const result = await this.knowledgeBase.addText(content, filename);
+    return { chunks: chunks.length, chars: content.length };
+  }
+}

package/src/skills/http.ts

@@ -1,35 +1,35 @@
-import { BaseSkill } from './base';
-import type { AgentContext, Message, SkillResult } from '../core/types';
-
-export class HttpSkill extends BaseSkill {
-  name = 'http';
-  description = 'Make HTTP requests to external APIs. Usage: http GET|POST|PUT|DELETE <url> [body]';
-
-  async execute(context: AgentContext, message: Message): Promise<SkillResult> {
-    const text = message.content.trim();
-    const match = text.match(/^http\s+(GET|POST|PUT|PATCH|DELETE)\s+(\S+)(?:\s+(.+))?$/is);
-    if (!match) return this.noMatch();
-
-    const [, method, url, bodyStr] = match;
-
-    try {
-      const opts: RequestInit = {
-        method: method.toUpperCase(),
-        headers: { 'Content-Type': 'application/json', 'User-Agent': 'OPC-Agent/0.7.0' },
-      };
-
-      if (bodyStr && ['POST', 'PUT', 'PATCH'].includes(method.toUpperCase())) {
-        opts.body = bodyStr;
-      }
-
-      const res = await fetch(url, opts);
-      const contentType = res.headers.get('content-type') ?? '';
-      const body = contentType.includes('json') ? JSON.stringify(await res.json(), null, 2) : await res.text();
-
-      const truncated = body.length > 4000 ? body.slice(0, 4000) + '\n...[truncated]' : body;
-      return this.match(`HTTP ${res.status} ${res.statusText}\n\n${truncated}`);
-    } catch (err) {
-      return this.match(`HTTP Error: ${err instanceof Error ? err.message : String(err)}`);
-    }
-  }
-}
+import { BaseSkill } from './base';
+import type { AgentContext, Message, SkillResult } from '../core/types';
+
+export class HttpSkill extends BaseSkill {
+  name = 'http';
+  description = 'Make HTTP requests to external APIs. Usage: http GET|POST|PUT|DELETE <url> [body]';
+
+  async execute(context: AgentContext, message: Message): Promise<SkillResult> {
+    const text = message.content.trim();
+    const match = text.match(/^http\s+(GET|POST|PUT|PATCH|DELETE)\s+(\S+)(?:\s+(.+))?$/is);
+    if (!match) return this.noMatch();
+
+    const [, method, url, bodyStr] = match;
+
+    try {
+      const opts: RequestInit = {
+        method: method.toUpperCase(),
+        headers: { 'Content-Type': 'application/json', 'User-Agent': 'OPC-Agent/0.7.0' },
+      };
+
+      if (bodyStr && ['POST', 'PUT', 'PATCH'].includes(method.toUpperCase())) {
+        opts.body = bodyStr;
+      }
+
+      const res = await fetch(url, opts);
+      const contentType = res.headers.get('content-type') ?? '';
+      const body = contentType.includes('json') ? JSON.stringify(await res.json(), null, 2) : await res.text();
+
+      const truncated = body.length > 4000 ? body.slice(0, 4000) + '\n...[truncated]' : body;
+      return this.match(`HTTP ${res.status} ${res.statusText}\n\n${truncated}`);
+    } catch (err) {
+      return this.match(`HTTP Error: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+}

package/src/skills/index.ts

@@ -1,27 +1,27 @@
-import type { ISkill, AgentContext, Message, SkillResult } from '../core/types';
-
-export type { ISkill } from '../core/types';
-
-export class SkillRegistry {
-  private skills: Map<string, ISkill> = new Map();
-
-  register(skill: ISkill): void {
-    this.skills.set(skill.name, skill);
-  }
-
-  get(name: string): ISkill | undefined {
-    return this.skills.get(name);
-  }
-
-  list(): ISkill[] {
-    return Array.from(this.skills.values());
-  }
-
-  async executeAll(context: AgentContext, message: Message): Promise<SkillResult | null> {
-    for (const skill of this.skills.values()) {
-      const result = await skill.execute(context, message);
-      if (result.handled) return result;
-    }
-    return null;
-  }
-}
+import type { ISkill, AgentContext, Message, SkillResult } from '../core/types';
+
+export type { ISkill } from '../core/types';
+
+export class SkillRegistry {
+  private skills: Map<string, ISkill> = new Map();
+
+  register(skill: ISkill): void {
+    this.skills.set(skill.name, skill);
+  }
+
+  get(name: string): ISkill | undefined {
+    return this.skills.get(name);
+  }
+
+  list(): ISkill[] {
+    return Array.from(this.skills.values());
+  }
+
+  async executeAll(context: AgentContext, message: Message): Promise<SkillResult | null> {
+    for (const skill of this.skills.values()) {
+      const result = await skill.execute(context, message);
+      if (result.handled) return result;
+    }
+    return null;
+  }
+}

package/src/skills/scheduler.ts

@@ -1,80 +1,80 @@
-import { BaseSkill } from './base';
-import type { AgentContext, Message, SkillResult } from '../core/types';
-
-export interface ScheduledTask {
-  id: string;
-  name: string;
-  cronExpr: string;
-  action: string;
-  enabled: boolean;
-  lastRun?: number;
-  nextRun?: number;
-}
-
-export class SchedulerSkill extends BaseSkill {
-  name = 'scheduler';
-  description = 'Schedule recurring tasks. Usage: schedule list | schedule add <name> <cron> <action> | schedule remove <id>';
-  private tasks: Map<string, ScheduledTask> = new Map();
-  private timers: Map<string, NodeJS.Timeout> = new Map();
-
-  async execute(context: AgentContext, message: Message): Promise<SkillResult> {
-    const text = message.content.trim();
-
-    if (/^schedule\s+list$/i.test(text)) {
-      if (this.tasks.size === 0) return this.match('No scheduled tasks.');
-      const lines = Array.from(this.tasks.values()).map(t =>
-        `• ${t.name} (${t.id}) — ${t.cronExpr} — ${t.enabled ? '✅' : '❌'} — Last: ${t.lastRun ? new Date(t.lastRun).toISOString() : 'never'}`
-      );
-      return this.match(`Scheduled tasks:\n${lines.join('\n')}`);
-    }
-
-    const addMatch = text.match(/^schedule\s+add\s+(\S+)\s+(".*?"|\S+)\s+(.+)$/i);
-    if (addMatch) {
-      const [, name, cronExpr, action] = addMatch;
-      const id = `task_${Date.now().toString(36)}`;
-      const task: ScheduledTask = {
-        id, name, cronExpr: cronExpr.replace(/"/g, ''), action, enabled: true,
-      };
-      this.tasks.set(id, task);
-      // Simple interval-based scheduling (parse cron for interval in minutes)
-      const intervalMs = this.parseCronToInterval(task.cronExpr);
-      if (intervalMs > 0) {
-        const timer = setInterval(() => {
-          task.lastRun = Date.now();
-        }, intervalMs);
-        this.timers.set(id, timer);
-      }
-      return this.match(`Task scheduled: ${name} (${id}) — ${task.cronExpr} → "${action}"`);
-    }
-
-    const rmMatch = text.match(/^schedule\s+remove\s+(\S+)$/i);
-    if (rmMatch) {
-      const id = rmMatch[1];
-      const timer = this.timers.get(id);
-      if (timer) clearInterval(timer);
-      this.timers.delete(id);
-      const removed = this.tasks.delete(id);
-      return this.match(removed ? `Task ${id} removed.` : `Task ${id} not found.`);
-    }
-
-    return this.noMatch();
-  }
-
-  private parseCronToInterval(expr: string): number {
-    // Simple: support "every Xm" or "every Xh" or basic intervals
-    const m = expr.match(/every\s+(\d+)\s*(m|min|h|hr|s|sec)/i);
-    if (m) {
-      const val = parseInt(m[1]);
-      const unit = m[2].toLowerCase();
-      if (unit.startsWith('h')) return val * 3600_000;
-      if (unit.startsWith('m')) return val * 60_000;
-      if (unit.startsWith('s')) return val * 1000;
-    }
-    return 0; // Unknown cron format, no auto-schedule
-  }
-
-  destroy(): void {
-    for (const timer of this.timers.values()) clearInterval(timer);
-    this.timers.clear();
-  }
-}
+import { BaseSkill } from './base';
+import type { AgentContext, Message, SkillResult } from '../core/types';
+
+export interface ScheduledTask {
+  id: string;
+  name: string;
+  cronExpr: string;
+  action: string;
+  enabled: boolean;
+  lastRun?: number;
+  nextRun?: number;
+}
+
+export class SchedulerSkill extends BaseSkill {
+  name = 'scheduler';
+  description = 'Schedule recurring tasks. Usage: schedule list | schedule add <name> <cron> <action> | schedule remove <id>';
+  private tasks: Map<string, ScheduledTask> = new Map();
+  private timers: Map<string, NodeJS.Timeout> = new Map();
+
+  async execute(context: AgentContext, message: Message): Promise<SkillResult> {
+    const text = message.content.trim();
+
+    if (/^schedule\s+list$/i.test(text)) {
+      if (this.tasks.size === 0) return this.match('No scheduled tasks.');
+      const lines = Array.from(this.tasks.values()).map(t =>
+        `• ${t.name} (${t.id}) — ${t.cronExpr} — ${t.enabled ? '✅' : '❌'} — Last: ${t.lastRun ? new Date(t.lastRun).toISOString() : 'never'}`
+      );
+      return this.match(`Scheduled tasks:\n${lines.join('\n')}`);
+    }
+
+    const addMatch = text.match(/^schedule\s+add\s+(\S+)\s+(".*?"|\S+)\s+(.+)$/i);
+    if (addMatch) {
+      const [, name, cronExpr, action] = addMatch;
+      const id = `task_${Date.now().toString(36)}`;
+      const task: ScheduledTask = {
+        id, name, cronExpr: cronExpr.replace(/"/g, ''), action, enabled: true,
+      };
+      this.tasks.set(id, task);
+      // Simple interval-based scheduling (parse cron for interval in minutes)
+      const intervalMs = this.parseCronToInterval(task.cronExpr);
+      if (intervalMs > 0) {
+        const timer = setInterval(() => {
+          task.lastRun = Date.now();
+        }, intervalMs);
+        this.timers.set(id, timer);
+      }
+      return this.match(`Task scheduled: ${name} (${id}) — ${task.cronExpr} → "${action}"`);
+    }
+
+    const rmMatch = text.match(/^schedule\s+remove\s+(\S+)$/i);
+    if (rmMatch) {
+      const id = rmMatch[1];
+      const timer = this.timers.get(id);
+      if (timer) clearInterval(timer);
+      this.timers.delete(id);
+      const removed = this.tasks.delete(id);
+      return this.match(removed ? `Task ${id} removed.` : `Task ${id} not found.`);
+    }
+
+    return this.noMatch();
+  }
+
+  private parseCronToInterval(expr: string): number {
+    // Simple: support "every Xm" or "every Xh" or basic intervals
+    const m = expr.match(/every\s+(\d+)\s*(m|min|h|hr|s|sec)/i);
+    if (m) {
+      const val = parseInt(m[1]);
+      const unit = m[2].toLowerCase();
+      if (unit.startsWith('h')) return val * 3600_000;
+      if (unit.startsWith('m')) return val * 60_000;
+      if (unit.startsWith('s')) return val * 1000;
+    }
+    return 0; // Unknown cron format, no auto-schedule
+  }
+
+  destroy(): void {
+    for (const timer of this.timers.values()) clearInterval(timer);
+    this.timers.clear();
+  }
+}

package/src/skills/webhook-trigger.ts

@@ -1,59 +1,59 @@
-import { BaseSkill } from './base';
-import type { AgentContext, Message, SkillResult } from '../core/types';
-
-export interface WebhookTarget {
-  name: string;
-  url: string;
-  method?: string;
-  headers?: Record<string, string>;
-  secret?: string;
-}
-
-export class WebhookTriggerSkill extends BaseSkill {
-  name = 'webhook-trigger';
-  description = 'Trigger external webhooks. Usage: webhook <name> [payload JSON]';
-  private targets: Map<string, WebhookTarget> = new Map();
-
-  registerTarget(target: WebhookTarget): void {
-    this.targets.set(target.name, target);
-  }
-
-  async execute(context: AgentContext, message: Message): Promise<SkillResult> {
-    const match = message.content.trim().match(/^webhook\s+(\S+)(?:\s+(.+))?$/is);
-    if (!match) return this.noMatch();
-
-    const [, name, payloadStr] = match;
-    const target = this.targets.get(name);
-    if (!target) {
-      const available = Array.from(this.targets.keys()).join(', ') || 'none';
-      return this.match(`Unknown webhook "${name}". Available: ${available}`);
-    }
-
-    try {
-      const headers: Record<string, string> = {
-        'Content-Type': 'application/json',
-        'User-Agent': 'OPC-Agent/0.7.0',
-        ...target.headers,
-      };
-      if (target.secret) {
-        headers['X-Webhook-Secret'] = target.secret;
-      }
-
-      const body = payloadStr ?? JSON.stringify({
-        agent: context.agentName,
-        timestamp: Date.now(),
-        trigger: 'manual',
-      });
-
-      const res = await fetch(target.url, {
-        method: target.method ?? 'POST',
-        headers,
-        body,
-      });
-
-      return this.match(`Webhook "${name}" triggered → ${res.status} ${res.statusText}`);
-    } catch (err) {
-      return this.match(`Webhook error: ${err instanceof Error ? err.message : String(err)}`);
-    }
-  }
-}
+import { BaseSkill } from './base';
+import type { AgentContext, Message, SkillResult } from '../core/types';
+
+export interface WebhookTarget {
+  name: string;
+  url: string;
+  method?: string;
+  headers?: Record<string, string>;
+  secret?: string;
+}
+
+export class WebhookTriggerSkill extends BaseSkill {
+  name = 'webhook-trigger';
+  description = 'Trigger external webhooks. Usage: webhook <name> [payload JSON]';
+  private targets: Map<string, WebhookTarget> = new Map();
+
+  registerTarget(target: WebhookTarget): void {
+    this.targets.set(target.name, target);
+  }
+
+  async execute(context: AgentContext, message: Message): Promise<SkillResult> {
+    const match = message.content.trim().match(/^webhook\s+(\S+)(?:\s+(.+))?$/is);
+    if (!match) return this.noMatch();
+
+    const [, name, payloadStr] = match;
+    const target = this.targets.get(name);
+    if (!target) {
+      const available = Array.from(this.targets.keys()).join(', ') || 'none';
+      return this.match(`Unknown webhook "${name}". Available: ${available}`);
+    }
+
+    try {
+      const headers: Record<string, string> = {
+        'Content-Type': 'application/json',
+        'User-Agent': 'OPC-Agent/0.7.0',
+        ...target.headers,
+      };
+      if (target.secret) {
+        headers['X-Webhook-Secret'] = target.secret;
+      }
+
+      const body = payloadStr ?? JSON.stringify({
+        agent: context.agentName,
+        timestamp: Date.now(),
+        trigger: 'manual',
+      });
+
+      const res = await fetch(target.url, {
+        method: target.method ?? 'POST',
+        headers,
+        body,
+      });
+
+      return this.match(`Webhook "${name}" triggered → ${res.status} ${res.statusText}`);
+    } catch (err) {
+      return this.match(`Webhook error: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+}