opc-agent 1.3.2 → 2.0.0

package/src/templates/teacher.ts

@@ -1,79 +1,75 @@
-import { BaseSkill } from '../skills/base';
-import type { AgentContext, Message, SkillResult } from '../core/types';
-
-export class LessonPlanSkill extends BaseSkill {
-  name = 'lesson-plan';
-  description = 'Create and manage lesson plans';
-
-  async execute(_context: AgentContext, message: Message): Promise<SkillResult> {
-    const lower = message.content.toLowerCase();
-    if (lower.includes('lesson') || lower.includes('plan') || lower.includes('curriculum') || lower.includes('syllabus')) {
-      return this.match('I can help create a lesson plan. What subject, grade level, and learning objectives should I focus on?', 0.85);
-    }
-    return this.noMatch();
-  }
-}
-
-export class QuizSkill extends BaseSkill {
-  name = 'quiz-generator';
-  description = 'Generate quizzes and assessments';
-
-  async execute(_context: AgentContext, message: Message): Promise<SkillResult> {
-    const lower = message.content.toLowerCase();
-    if (lower.includes('quiz') || lower.includes('test') || lower.includes('assessment') || lower.includes('exam') || lower.includes('question')) {
-      return this.match('I\'ll create a quiz for you. What topic, difficulty level, and number of questions would you like?', 0.85);
-    }
-    return this.noMatch();
-  }
-}
-
-export class ExplainSkill extends BaseSkill {
-  name = 'concept-explainer';
-  description = 'Explain concepts at appropriate level';
-
-  async execute(_context: AgentContext, message: Message): Promise<SkillResult> {
-    const lower = message.content.toLowerCase();
-    if (lower.includes('explain') || lower.includes('what is') || lower.includes('how does') || lower.includes('why')) {
-      return this.match('Let me explain that concept. What\'s your current level of understanding so I can tailor my explanation?', 0.75);
-    }
-    return this.noMatch();
-  }
-}
-
-export const TEACHER_SYSTEM_PROMPT = `You are a patient and encouraging teacher assistant. Your goals:
-1. Create engaging lesson plans tailored to student level
-2. Generate quizzes and assessments with answer keys
-3. Explain complex concepts using analogies and examples
-4. Provide constructive feedback and encouragement
-5. Adapt teaching style to different learning preferences
-Be patient, use clear language, and always check for understanding. Use the Socratic method when appropriate.`;
-
-export function createTeacherConfig() {
-  return {
-    apiVersion: 'opc/v1' as const,
-    kind: 'Agent' as const,
-    metadata: {
-      name: 'teacher',
-      version: '1.0.0',
-      description: 'AI teacher assistant with lesson planning, quiz generation, and concept explanation',
-      author: 'OPC Agent',
-      license: 'Apache-2.0',
-    },
-    spec: {
-      provider: { default: 'openai', allowed: ['openai', 'deepseek', 'qwen'] },
-      model: 'gpt-4o-mini',
-      systemPrompt: TEACHER_SYSTEM_PROMPT,
-      skills: [
-        { name: 'lesson-plan', description: 'Create lesson plans' },
-        { name: 'quiz-generator', description: 'Generate quizzes' },
-        { name: 'concept-explainer', description: 'Explain concepts' },
-      ],
-      channels: [{ type: 'web' as const, port: 3000 }],
-      memory: { shortTerm: true, longTerm: true },
-      dtv: {
-        trust: { level: 'sandbox' as const },
-        value: { metrics: ['lessons_created', 'quizzes_generated', 'concepts_explained'] },
-      },
-    },
-  };
-}
+import { BaseSkill } from '../skills/base';
+import type { AgentContext, Message, SkillResult } from '../core/types';
+
+export class LessonPlanSkill extends BaseSkill {
+  name = 'lesson-plan';
+  description = 'Create and manage lesson plans';
+
+  async execute(_context: AgentContext, message: Message): Promise<SkillResult> {
+    const lower = message.content.toLowerCase();
+    if (lower.includes('lesson') || lower.includes('plan') || lower.includes('curriculum') || lower.includes('syllabus')) {
+      return this.match('I can help create a lesson plan. What subject, grade level, and learning objectives should I focus on?', 0.85);
+    }
+    return this.noMatch();
+  }
+}
+
+export class QuizSkill extends BaseSkill {
+  name = 'quiz-generator';
+  description = 'Generate quizzes and assessments';
+
+  async execute(_context: AgentContext, message: Message): Promise<SkillResult> {
+    const lower = message.content.toLowerCase();
+    if (lower.includes('quiz') || lower.includes('test') || lower.includes('assessment') || lower.includes('exam') || lower.includes('question')) {
+      return this.match('I\'ll create a quiz for you. What topic, difficulty level, and number of questions would you like?', 0.85);
+    }
+    return this.noMatch();
+  }
+}
+
+export class ExplainSkill extends BaseSkill {
+  name = 'concept-explainer';
+  description = 'Explain concepts at appropriate level';
+
+  async execute(_context: AgentContext, message: Message): Promise<SkillResult> {
+    const lower = message.content.toLowerCase();
+    if (lower.includes('explain') || lower.includes('what is') || lower.includes('how does') || lower.includes('why')) {
+      return this.match('Let me explain that concept. What\'s your current level of understanding so I can tailor my explanation?', 0.75);
+    }
+    return this.noMatch();
+  }
+}
+
+export const TEACHER_SYSTEM_PROMPT = `You are a patient and encouraging teacher assistant. Your goals:
+1. Create engaging lesson plans tailored to student level
+2. Generate quizzes and assessments with answer keys
+3. Explain complex concepts using analogies and examples
+4. Provide constructive feedback and encouragement
+5. Adapt teaching style to different learning preferences
+Be patient, use clear language, and always check for understanding. Use the Socratic method when appropriate.`;
+
+export function createTeacherConfig() {
+  return {
+    apiVersion: 'opc/v1' as const,
+    kind: 'Agent' as const,
+    metadata: {
+      name: 'teacher',
+      version: '1.0.0',
+      description: 'AI teacher assistant with lesson planning, quiz generation, and concept explanation',
+      author: 'OPC Agent',
+      license: 'Apache-2.0',
+    },
+    spec: {
+      provider: { default: 'openai', allowed: ['openai', 'deepseek', 'qwen'] },
+      model: 'gpt-4o-mini',
+      systemPrompt: TEACHER_SYSTEM_PROMPT,
+      skills: [
+        { name: 'lesson-plan', description: 'Create lesson plans' },
+        { name: 'quiz-generator', description: 'Generate quizzes' },
+        { name: 'concept-explainer', description: 'Explain concepts' },
+      ],
+      channels: [{ type: 'web' as const, port: 3000 }],
+      memory: { shortTerm: true, longTerm: true },
+    },
+  };
+}

package/src/testing/index.ts

@@ -1,181 +1,181 @@
-/**
- * Agent Testing Framework - Define test cases in OAD, run with `opc test`.
- * Supports assertions on response content, tool calls, and latency.
- */
-import * as fs from 'fs';
-import * as path from 'path';
-import * as yaml from 'js-yaml';
-import { AgentRuntime } from '../core/runtime';
-
-export interface TestCase {
-  name: string;
-  input: string;
-  expect?: {
-    contains?: string[];
-    notContains?: string[];
-    toolCalled?: string[];
-    maxLatencyMs?: number;
-  };
-}
-
-export interface TestResult {
-  name: string;
-  passed: boolean;
-  durationMs: number;
-  response?: string;
-  failures: string[];
-}
-
-export interface TestReport {
-  total: number;
-  passed: number;
-  failed: number;
-  duration: number;
-  results: TestResult[];
-}
-
-/**
- * Load test cases from OAD spec.testing or a separate test file.
- */
-export function loadTestCases(oadPath: string): TestCase[] {
-  const raw = fs.readFileSync(oadPath, 'utf-8');
-  const config = yaml.load(raw) as any;
-
-  // Check spec.testing.cases
-  if (config?.spec?.testing?.cases) {
-    return config.spec.testing.cases;
-  }
-
-  // Check for companion test file
-  const dir = path.dirname(oadPath);
-  const testFile = path.join(dir, 'tests.yaml');
-  if (fs.existsSync(testFile)) {
-    const testRaw = fs.readFileSync(testFile, 'utf-8');
-    const testConfig = yaml.load(testRaw) as any;
-    return testConfig?.cases ?? testConfig ?? [];
-  }
-
-  return [];
-}
-
-/**
- * Run all test cases against an agent.
- */
-export async function runTests(oadPath: string): Promise<TestReport> {
-  const cases = loadTestCases(oadPath);
-  const results: TestResult[] = [];
-  const startTime = Date.now();
-
-  if (cases.length === 0) {
-    // Generate default smoke test
-    cases.push({
-      name: 'smoke-test',
-      input: 'Hello! What can you help me with?',
-      expect: { maxLatencyMs: 30000 },
-    });
-  }
-
-  const runtime = new AgentRuntime();
-  await runtime.loadConfig(oadPath);
-  const agent = await runtime.initialize();
-
-  for (const tc of cases) {
-    const result: TestResult = {
-      name: tc.name,
-      passed: true,
-      durationMs: 0,
-      failures: [],
-    };
-
-    const t0 = Date.now();
-    try {
-      const response = await agent.handleMessage({
-        id: `test_${Date.now()}`,
-        role: 'user',
-        content: tc.input,
-        timestamp: Date.now(),
-      });
-      result.durationMs = Date.now() - t0;
-      result.response = response.content;
-
-      if (tc.expect) {
-        // Check contains
-        if (tc.expect.contains) {
-          for (const s of tc.expect.contains) {
-            if (!response.content.toLowerCase().includes(s.toLowerCase())) {
-              result.failures.push(`Expected response to contain "${s}"`);
-            }
-          }
-        }
-        // Check notContains
-        if (tc.expect.notContains) {
-          for (const s of tc.expect.notContains) {
-            if (response.content.toLowerCase().includes(s.toLowerCase())) {
-              result.failures.push(`Expected response NOT to contain "${s}"`);
-            }
-          }
-        }
-        // Check latency
-        if (tc.expect.maxLatencyMs && result.durationMs > tc.expect.maxLatencyMs) {
-          result.failures.push(`Latency ${result.durationMs}ms exceeded max ${tc.expect.maxLatencyMs}ms`);
-        }
-        // Check tool calls (from metadata if available)
-        if (tc.expect.toolCalled && (response as any).toolsCalled) {
-          for (const tool of tc.expect.toolCalled) {
-            if (!(response as any).toolsCalled.includes(tool)) {
-              result.failures.push(`Expected tool "${tool}" to be called`);
-            }
-          }
-        }
-      }
-
-      result.passed = result.failures.length === 0;
-    } catch (err) {
-      result.durationMs = Date.now() - t0;
-      result.passed = false;
-      result.failures.push(`Error: ${err instanceof Error ? err.message : String(err)}`);
-    }
-
-    results.push(result);
-  }
-
-  const totalDuration = Date.now() - startTime;
-  const passed = results.filter(r => r.passed).length;
-
-  return {
-    total: results.length,
-    passed,
-    failed: results.length - passed,
-    duration: totalDuration,
-    results,
-  };
-}
-
-/**
- * Format test report for console output.
- */
-export function formatReport(report: TestReport): string {
-  const lines: string[] = [];
-  lines.push('');
-  lines.push('═══════════════════════════════════════════');
-  lines.push('  OPC Agent Test Report');
-  lines.push('═══════════════════════════════════════════');
-  lines.push('');
-
-  for (const r of report.results) {
-    const icon = r.passed ? '✔' : '✘';
-    const status = r.passed ? 'PASS' : 'FAIL';
-    lines.push(`  ${icon} [${status}] ${r.name} (${r.durationMs}ms)`);
-    for (const f of r.failures) {
-      lines.push(`      → ${f}`);
-    }
-  }
-
-  lines.push('');
-  lines.push('───────────────────────────────────────────');
-  lines.push(`  Total: ${report.total}  Passed: ${report.passed}  Failed: ${report.failed}  Duration: ${report.duration}ms`);
-  lines.push('───────────────────────────────────────────');
-  lines.push('');
-
-  return lines.join('\n');
-}
+/**
+ * Agent Testing Framework - Define test cases in OAD, run with `opc test`.
+ * Supports assertions on response content, tool calls, and latency.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import * as yaml from 'js-yaml';
+import { AgentRuntime } from '../core/runtime';
+
+export interface TestCase {
+  name: string;
+  input: string;
+  expect?: {
+    contains?: string[];
+    notContains?: string[];
+    toolCalled?: string[];
+    maxLatencyMs?: number;
+  };
+}
+
+export interface TestResult {
+  name: string;
+  passed: boolean;
+  durationMs: number;
+  response?: string;
+  failures: string[];
+}
+
+export interface TestReport {
+  total: number;
+  passed: number;
+  failed: number;
+  duration: number;
+  results: TestResult[];
+}
+
+/**
+ * Load test cases from OAD spec.testing or a separate test file.
+ */
+export function loadTestCases(oadPath: string): TestCase[] {
+  const raw = fs.readFileSync(oadPath, 'utf-8');
+  const config = yaml.load(raw) as any;
+
+  // Check spec.testing.cases
+  if (config?.spec?.testing?.cases) {
+    return config.spec.testing.cases;
+  }
+
+  // Check for companion test file
+  const dir = path.dirname(oadPath);
+  const testFile = path.join(dir, 'tests.yaml');
+  if (fs.existsSync(testFile)) {
+    const testRaw = fs.readFileSync(testFile, 'utf-8');
+    const testConfig = yaml.load(testRaw) as any;
+    return testConfig?.cases ?? testConfig ?? [];
+  }
+
+  return [];
+}
+
+/**
+ * Run all test cases against an agent.
+ */
+export async function runTests(oadPath: string): Promise<TestReport> {
+  const cases = loadTestCases(oadPath);
+  const results: TestResult[] = [];
+  const startTime = Date.now();
+
+  if (cases.length === 0) {
+    // Generate default smoke test
+    cases.push({
+      name: 'smoke-test',
+      input: 'Hello! What can you help me with?',
+      expect: { maxLatencyMs: 30000 },
+    });
+  }
+
+  const runtime = new AgentRuntime();
+  await runtime.loadConfig(oadPath);
+  const agent = await runtime.initialize();
+
+  for (const tc of cases) {
+    const result: TestResult = {
+      name: tc.name,
+      passed: true,
+      durationMs: 0,
+      failures: [],
+    };
+
+    const t0 = Date.now();
+    try {
+      const response = await agent.handleMessage({
+        id: `test_${Date.now()}`,
+        role: 'user',
+        content: tc.input,
+        timestamp: Date.now(),
+      });
+      result.durationMs = Date.now() - t0;
+      result.response = response.content;
+
+      if (tc.expect) {
+        // Check contains
+        if (tc.expect.contains) {
+          for (const s of tc.expect.contains) {
+            if (!response.content.toLowerCase().includes(s.toLowerCase())) {
+              result.failures.push(`Expected response to contain "${s}"`);
+            }
+          }
+        }
+        // Check notContains
+        if (tc.expect.notContains) {
+          for (const s of tc.expect.notContains) {
+            if (response.content.toLowerCase().includes(s.toLowerCase())) {
+              result.failures.push(`Expected response NOT to contain "${s}"`);
+            }
+          }
+        }
+        // Check latency
+        if (tc.expect.maxLatencyMs && result.durationMs > tc.expect.maxLatencyMs) {
+          result.failures.push(`Latency ${result.durationMs}ms exceeded max ${tc.expect.maxLatencyMs}ms`);
+        }
+        // Check tool calls (from metadata if available)
+        if (tc.expect.toolCalled && (response as any).toolsCalled) {
+          for (const tool of tc.expect.toolCalled) {
+            if (!(response as any).toolsCalled.includes(tool)) {
+              result.failures.push(`Expected tool "${tool}" to be called`);
+            }
+          }
+        }
+      }
+
+      result.passed = result.failures.length === 0;
+    } catch (err) {
+      result.durationMs = Date.now() - t0;
+      result.passed = false;
+      result.failures.push(`Error: ${err instanceof Error ? err.message : String(err)}`);
+    }
+
+    results.push(result);
+  }
+
+  const totalDuration = Date.now() - startTime;
+  const passed = results.filter(r => r.passed).length;
+
+  return {
+    total: results.length,
+    passed,
+    failed: results.length - passed,
+    duration: totalDuration,
+    results,
+  };
+}
+
+/**
+ * Format test report for console output.
+ */
+export function formatReport(report: TestReport): string {
+  const lines: string[] = [];
+  lines.push('');
+  lines.push('═══════════════════════════════════════════');
+  lines.push('  OPC Agent Test Report');
+  lines.push('═══════════════════════════════════════════');
+  lines.push('');
+
+  for (const r of report.results) {
+    const icon = r.passed ? '✔' : '✘';
+    const status = r.passed ? 'PASS' : 'FAIL';
+    lines.push(`  ${icon} [${status}] ${r.name} (${r.durationMs}ms)`);
+    for (const f of r.failures) {
+      lines.push(`      → ${f}`);
+    }
+  }
+
+  lines.push('');
+  lines.push('───────────────────────────────────────────');
+  lines.push(`  Total: ${report.total}  Passed: ${report.passed}  Failed: ${report.failed}  Duration: ${report.duration}ms`);
+  lines.push('───────────────────────────────────────────');
+  lines.push('');
+
+  return lines.join('\n');
+}

package/src/tools/builtin/datetime.ts

@@ -0,0 +1,41 @@
+import type { MCPTool, MCPToolResult } from '../mcp';
+
+export const datetimeTool: MCPTool = {
+  name: 'datetime',
+  description: 'Get current date, time, timezone info',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      format: { type: 'string', default: 'iso' },
+      timezone: { type: 'string' },
+    },
+  },
+  async execute(input: Record<string, unknown>): Promise<MCPToolResult> {
+    const now = new Date();
+    const timezone = input.timezone as string | undefined;
+    const format = (input.format as string) || 'iso';
+
+    let content: string;
+    if (format === 'iso') {
+      content = now.toISOString();
+    } else if (format === 'locale') {
+      content = timezone
+        ? now.toLocaleString('en-US', { timeZone: timezone })
+        : now.toLocaleString();
+    } else if (format === 'unix') {
+      content = String(Math.floor(now.getTime() / 1000));
+    } else {
+      content = now.toISOString();
+    }
+
+    return {
+      content: JSON.stringify({
+        iso: now.toISOString(),
+        unix: Math.floor(now.getTime() / 1000),
+        formatted: content,
+        timezone: timezone || Intl.DateTimeFormat().resolvedOptions().timeZone,
+      }),
+      isError: false,
+    };
+  },
+};

package/src/tools/builtin/file.ts

@@ -0,0 +1,107 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import type { MCPTool, MCPToolResult } from '../mcp';
+import type { AgentContext } from '../../core/types';
+
+function resolveSafe(basePath: string, targetPath: string): string | null {
+  const resolved = path.resolve(basePath, targetPath);
+  if (!resolved.startsWith(path.resolve(basePath))) return null;
+  return resolved;
+}
+
+function searchFiles(dir: string, query: string, results: string[] = [], maxResults = 20): string[] {
+  if (results.length >= maxResults) return results;
+  try {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (results.length >= maxResults) break;
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (entry.name === 'node_modules' || entry.name === '.git') continue;
+        searchFiles(full, query, results, maxResults);
+      } else if (entry.isFile()) {
+        try {
+          const content = fs.readFileSync(full, 'utf-8');
+          const lines = content.split('\n');
+          for (let i = 0; i < lines.length; i++) {
+            if (lines[i].includes(query)) {
+              results.push(`${full}:${i + 1}: ${lines[i].trim()}`);
+              if (results.length >= maxResults) break;
+            }
+          }
+        } catch { /* skip binary/unreadable */ }
+      }
+    }
+  } catch { /* skip inaccessible dirs */ }
+  return results;
+}
+
+export const fileTool: MCPTool = {
+  name: 'file_operations',
+  description: 'Read, write, list, and search files in the workspace',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      action: { type: 'string', enum: ['read', 'write', 'list', 'search', 'exists'] },
+      path: { type: 'string' },
+      content: { type: 'string' },
+      query: { type: 'string' },
+    },
+    required: ['action'],
+  },
+  async execute(input: Record<string, unknown>, context?: AgentContext): Promise<MCPToolResult> {
+    const action = input.action as string;
+    const workspace = process.cwd();
+    const targetPath = input.path as string | undefined;
+
+    if (action === 'search') {
+      const query = input.query as string;
+      if (!query) return { content: 'query is required for search', isError: true };
+      const results = searchFiles(workspace, query);
+      return { content: results.length ? results.join('\n') : 'No matches found', isError: false };
+    }
+
+    if (action === 'list') {
+      const dir = targetPath ? resolveSafe(workspace, targetPath) : workspace;
+      if (!dir) return { content: 'Path outside workspace', isError: true };
+      try {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        const listing = entries.map(e => `${e.isDirectory() ? '[DIR] ' : ''}${e.name}`).join('\n');
+        return { content: listing || '(empty directory)', isError: false };
+      } catch (err) {
+        return { content: `Error listing directory: ${err instanceof Error ? err.message : String(err)}`, isError: true };
+      }
+    }
+
+    if (!targetPath) return { content: 'path is required', isError: true };
+    const resolved = resolveSafe(workspace, targetPath);
+    if (!resolved) return { content: 'Path outside workspace', isError: true };
+
+    switch (action) {
+      case 'read': {
+        try {
+          const content = fs.readFileSync(resolved, 'utf-8');
+          return { content: content.slice(0, 50000), isError: false };
+        } catch (err) {
+          return { content: `Error reading file: ${err instanceof Error ? err.message : String(err)}`, isError: true };
+        }
+      }
+      case 'write': {
+        const content = input.content as string;
+        if (content === undefined) return { content: 'content is required for write', isError: true };
+        try {
+          fs.mkdirSync(path.dirname(resolved), { recursive: true });
+          fs.writeFileSync(resolved, content, 'utf-8');
+          return { content: `Written ${content.length} bytes to ${targetPath}`, isError: false };
+        } catch (err) {
+          return { content: `Error writing file: ${err instanceof Error ? err.message : String(err)}`, isError: true };
+        }
+      }
+      case 'exists': {
+        return { content: String(fs.existsSync(resolved)), isError: false };
+      }
+      default:
+        return { content: `Unknown action: ${action}`, isError: true };
+    }
+  },
+};