opc-agent 4.1.2 → 4.1.4

package/src/skills/document.ts

@@ -1,100 +0,0 @@
-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 +0,0 @@
-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 +0,0 @@
-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/marketplace.ts

@@ -1,113 +0,0 @@
-/**
- * Skill Marketplace Manager
- * Handles skill installation, uninstallation, and runtime discovery.
- */
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
-import { join } from 'path';
-import * as os from 'os';
-import type { MarketplaceSkill, InstalledSkill, SkillInstallResult, SkillCategory } from './types';
-import { BUILTIN_SKILLS } from './builtin/index';
-
-export class SkillMarketplace {
-  private installedSkills: Map<string, InstalledSkill> = new Map();
-  private configPath: string;
-
-  constructor() {
-    const dir = join(os.homedir(), '.opc');
-    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-    this.configPath = join(dir, 'skills-installed.json');
-    this.loadInstalled();
-  }
-
-  private loadInstalled(): void {
-    if (existsSync(this.configPath)) {
-      try {
-        const data = JSON.parse(readFileSync(this.configPath, 'utf-8'));
-        if (Array.isArray(data)) {
-          data.forEach((s: InstalledSkill) => this.installedSkills.set(s.skillId, s));
-        }
-      } catch { /* ignore corrupted file */ }
-    }
-  }
-
-  private saveInstalled(): void {
-    const data = Array.from(this.installedSkills.values());
-    writeFileSync(this.configPath, JSON.stringify(data, null, 2));
-  }
-
-  /** Get all available skills with installation status */
-  listAll(category?: string, search?: string): (MarketplaceSkill & { installed: boolean })[] {
-    let skills = BUILTIN_SKILLS;
-    if (category) {
-      skills = skills.filter(s => s.category === category);
-    }
-    if (search) {
-      const q = search.toLowerCase();
-      skills = skills.filter(s =>
-        s.name.toLowerCase().includes(q) ||
-        s.nameZh.includes(q) ||
-        s.description.toLowerCase().includes(q) ||
-        s.descriptionZh.includes(q)
-      );
-    }
-    return skills.map(s => ({
-      ...s,
-      installed: this.installedSkills.has(s.id),
-    }));
-  }
-
-  /** Get a single skill by ID */
-  getSkill(id: string): (MarketplaceSkill & { installed: boolean }) | null {
-    const skill = BUILTIN_SKILLS.find(s => s.id === id);
-    if (!skill) return null;
-    return { ...skill, installed: this.installedSkills.has(id) };
-  }
-
-  /** Install a skill */
-  install(id: string, config?: Record<string, any>): SkillInstallResult {
-    const skill = BUILTIN_SKILLS.find(s => s.id === id);
-    if (!skill) return { success: false, skillId: id, message: 'Skill not found' };
-    if (this.installedSkills.has(id)) return { success: true, skillId: id, message: 'Already installed' };
-
-    this.installedSkills.set(id, {
-      skillId: id,
-      installedAt: new Date().toISOString(),
-      config,
-    });
-    this.saveInstalled();
-    return { success: true, skillId: id, message: 'Installed successfully' };
-  }
-
-  /** Uninstall a skill */
-  uninstall(id: string): SkillInstallResult {
-    if (!this.installedSkills.has(id)) {
-      return { success: false, skillId: id, message: 'Skill not installed' };
-    }
-    this.installedSkills.delete(id);
-    this.saveInstalled();
-    return { success: true, skillId: id, message: 'Uninstalled successfully' };
-  }
-
-  /** Get installed skills with full details */
-  getInstalled(): (MarketplaceSkill & { installed: boolean; installedAt: string })[] {
-    return Array.from(this.installedSkills.values())
-      .map(inst => {
-        const skill = BUILTIN_SKILLS.find(s => s.id === inst.skillId);
-        if (!skill) return null;
-        return { ...skill, installed: true, installedAt: inst.installedAt };
-      })
-      .filter(Boolean) as any;
-  }
-
-  /** Get system prompts for all installed skills (for agent runtime) */
-  getInstalledSystemPrompts(): string[] {
-    return this.getInstalled()
-      .filter(s => s.systemPrompt)
-      .map(s => `[${s.icon} ${s.nameZh}] ${s.systemPrompt}`);
-  }
-
-  /** Get all tool names from installed skills */
-  getInstalledToolNames(): string[] {
-    return this.getInstalled().flatMap(s => s.tools);
-  }
-}

package/src/skills/scheduler.ts

@@ -1,80 +0,0 @@
-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/types.ts

@@ -1,42 +0,0 @@
-/**
- * Skill Marketplace - Type Definitions
- * Defines the structure for installable skills in the OPC Agent marketplace.
- */
-
-export interface MarketplaceSkill {
-  id: string;
-  name: string;
-  nameZh: string;
-  description: string;
-  descriptionZh: string;
-  category: SkillCategory;
-  icon: string;
-  version: string;
-  author: string;
-  tools: string[];
-  config?: Record<string, any>;
-  systemPrompt?: string;
-}
-
-export type SkillCategory = 'productivity' | 'knowledge' | 'creative' | 'developer' | 'lifestyle' | 'business';
-
-export interface InstalledSkill {
-  skillId: string;
-  installedAt: string;
-  config?: Record<string, any>;
-}
-
-export interface SkillInstallResult {
-  success: boolean;
-  skillId: string;
-  message?: string;
-}
-
-export const CATEGORY_LABELS: Record<SkillCategory, { en: string; zh: string }> = {
-  productivity: { en: 'Productivity', zh: '效率工具' },
-  knowledge: { en: 'Knowledge', zh: '知识工具' },
-  creative: { en: 'Creative', zh: '创作工具' },
-  developer: { en: 'Developer', zh: '开发工具' },
-  lifestyle: { en: 'Lifestyle', zh: '生活工具' },
-  business: { en: 'Business', zh: '业务工具' },
-};

package/src/skills/webhook-trigger.ts

@@ -1,59 +0,0 @@
-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)}`);
-    }
-  }
-}