opc-agent 1.3.2 → 2.0.0

package/test-agent/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "test-agent",
+  "version": "1.0.0",
+  "private": true,
+  "scripts": {
+    "start": "opc run",
+    "dev": "opc dev",
+    "chat": "opc chat",
+    "build": "tsc"
+  },
+  "dependencies": {
+    "opc-agent": "^1.3.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.5.0",
+    "tsx": "^4.0.0"
+  }
+}

package/test-agent/src/index.ts

@@ -0,0 +1,24 @@
+import { AgentRuntime } from 'opc-agent';
+import { EchoSkill } from './skills/echo';
+
+async function main() {
+  const runtime = new AgentRuntime();
+
+  // Load OAD config
+  await runtime.loadConfig('./agent.yaml');
+
+  // Initialize agent with channels, memory, etc.
+  const agent = await runtime.initialize();
+
+  // Register custom skills
+  runtime.registerSkill(new EchoSkill());
+
+  // Start serving
+  await runtime.start();
+
+  console.log('🤖 Agent is running!');
+  console.log('   Web UI: http://localhost:3000');
+  console.log('   Press Ctrl+C to stop');
+}
+
+main().catch(console.error);

package/test-agent/src/skills/echo.ts

@@ -0,0 +1,15 @@
+import { BaseSkill } from 'opc-agent';
+import type { AgentContext, Message, SkillResult } from 'opc-agent';
+
+export class EchoSkill extends BaseSkill {
+  name = 'echo';
+  description = 'Echo back the message (test skill)';
+
+  async execute(context: AgentContext, message: Message): Promise<SkillResult> {
+    if (message.content.toLowerCase().startsWith('/echo ')) {
+      const text = message.content.slice(6);
+      return this.match(`🔊 Echo: ${text}`);
+    }
+    return this.noMatch();
+  }
+}

package/test-agent/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "lib": [
+      "ES2022"
+    ],
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "sourceMap": true
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist"
+  ]
+}

package/tests/a2a.test.ts

@@ -1,66 +1,66 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { AgentRegistry } from '../src/core/a2a';
-import { BaseAgent } from '../src/core/agent';
-import { InMemoryStore } from '../src/memory';
-
-function createTestAgent(name: string): BaseAgent {
-  const agent = new BaseAgent({ name, model: 'test', systemPrompt: `I am ${name}` }, new InMemoryStore());
-  return agent;
-}
-
-describe('AgentRegistry (A2A)', () => {
-  let registry: AgentRegistry;
-
-  beforeEach(() => {
-    registry = new AgentRegistry();
-  });
-
-  it('should register and discover agents', () => {
-    const agent = createTestAgent('agent-1');
-    registry.register(agent, [{ name: 'summarize', description: 'Summarize text' }]);
-    
-    const all = registry.discover();
-    expect(all).toHaveLength(1);
-    expect(all[0].agentName).toBe('agent-1');
-  });
-
-  it('should discover by capability', () => {
-    const a1 = createTestAgent('a1');
-    const a2 = createTestAgent('a2');
-    registry.register(a1, [{ name: 'summarize', description: 'Summarize' }]);
-    registry.register(a2, [{ name: 'translate', description: 'Translate' }]);
-
-    const found = registry.discover('translate');
-    expect(found).toHaveLength(1);
-    expect(found[0].agentName).toBe('a2');
-  });
-
-  it('should unregister agents', () => {
-    const agent = createTestAgent('temp');
-    registry.register(agent, []);
-    registry.unregister('temp');
-    expect(registry.discover()).toHaveLength(0);
-  });
-
-  it('should handle request to unknown agent', async () => {
-    const response = await registry.call('a1', 'unknown', 'test', 'hello');
-    expect(response.status).toBe('error');
-  });
-
-  it('should send A2A request and get response', async () => {
-    const agent = createTestAgent('responder');
-    await agent.init();
-    registry.register(agent, [{ name: 'chat', description: 'Chat' }]);
-
-    const response = await registry.call('caller', 'responder', 'chat', 'hello');
-    expect(response.status).toBe('success');
-    expect(response.payload).toBeDefined();
-  });
-
-  it('should get agent by name', () => {
-    const agent = createTestAgent('finder');
-    registry.register(agent, []);
-    expect(registry.getAgent('finder')).toBeDefined();
-    expect(registry.getAgent('none')).toBeUndefined();
-  });
-});
+import { describe, it, expect, beforeEach } from 'vitest';
+import { AgentRegistry } from '../src/core/a2a';
+import { BaseAgent } from '../src/core/agent';
+import { InMemoryStore } from '../src/memory';
+
+function createTestAgent(name: string): BaseAgent {
+  const agent = new BaseAgent({ name, model: 'test', systemPrompt: `I am ${name}` }, new InMemoryStore());
+  return agent;
+}
+
+describe('AgentRegistry (A2A)', () => {
+  let registry: AgentRegistry;
+
+  beforeEach(() => {
+    registry = new AgentRegistry();
+  });
+
+  it('should register and discover agents', () => {
+    const agent = createTestAgent('agent-1');
+    registry.register(agent, [{ name: 'summarize', description: 'Summarize text' }]);
+    
+    const all = registry.discover();
+    expect(all).toHaveLength(1);
+    expect(all[0].agentName).toBe('agent-1');
+  });
+
+  it('should discover by capability', () => {
+    const a1 = createTestAgent('a1');
+    const a2 = createTestAgent('a2');
+    registry.register(a1, [{ name: 'summarize', description: 'Summarize' }]);
+    registry.register(a2, [{ name: 'translate', description: 'Translate' }]);
+
+    const found = registry.discover('translate');
+    expect(found).toHaveLength(1);
+    expect(found[0].agentName).toBe('a2');
+  });
+
+  it('should unregister agents', () => {
+    const agent = createTestAgent('temp');
+    registry.register(agent, []);
+    registry.unregister('temp');
+    expect(registry.discover()).toHaveLength(0);
+  });
+
+  it('should handle request to unknown agent', async () => {
+    const response = await registry.call('a1', 'unknown', 'test', 'hello');
+    expect(response.status).toBe('error');
+  });
+
+  it('should send A2A request and get response', async () => {
+    const agent = createTestAgent('responder');
+    await agent.init();
+    registry.register(agent, [{ name: 'chat', description: 'Chat' }]);
+
+    const response = await registry.call('caller', 'responder', 'chat', 'hello');
+    expect(response.status).toBe('success');
+    expect(response.payload).toBeDefined();
+  });
+
+  it('should get agent by name', () => {
+    const agent = createTestAgent('finder');
+    registry.register(agent, []);
+    expect(registry.getAgent('finder')).toBeDefined();
+    expect(registry.getAgent('none')).toBeUndefined();
+  });
+});

package/tests/agent.test.ts

@@ -1,72 +1,72 @@
-import { describe, it, expect } from 'vitest';
-import { BaseAgent } from '../src/core/agent';
-
-describe('BaseAgent', () => {
-  it('should start in init state', () => {
-    const agent = new BaseAgent({ name: 'test' });
-    expect(agent.state).toBe('init');
-    expect(agent.name).toBe('test');
-  });
-
-  it('should transition through lifecycle', async () => {
-    const agent = new BaseAgent({ name: 'test' });
-    const states: string[] = [];
-    agent.on('state:change', (_from, to) => states.push(to));
-
-    await agent.init();
-    expect(agent.state).toBe('ready');
-
-    await agent.start();
-    expect(agent.state).toBe('running');
-
-    await agent.stop();
-    expect(agent.state).toBe('stopped');
-
-    expect(states).toEqual(['ready', 'running', 'stopped']);
-  });
-
-  it('should not start if not ready', async () => {
-    const agent = new BaseAgent({ name: 'test' });
-    await expect(agent.start()).rejects.toThrow('Cannot start agent in state: init');
-  });
-
-  it('should handle messages with stub provider', async () => {
-    const agent = new BaseAgent({ name: 'test', systemPrompt: 'Be helpful' });
-    await agent.init();
-
-    const response = await agent.handleMessage({
-      id: 'msg_1',
-      role: 'user',
-      content: 'Hello',
-      timestamp: Date.now(),
-    });
-
-    expect(response.role).toBe('assistant');
-    expect(response.content).toContain('Hello');
-  });
-
-  it('should use skills before LLM fallback', async () => {
-    const agent = new BaseAgent({ name: 'test' });
-    await agent.init();
-
-    agent.registerSkill({
-      name: 'greeter',
-      description: 'Greets users',
-      execute: async (_ctx, msg) => {
-        if (msg.content.toLowerCase().includes('hello')) {
-          return { handled: true, response: 'Hi there!', confidence: 1.0 };
-        }
-        return { handled: false, confidence: 0 };
-      },
-    });
-
-    const response = await agent.handleMessage({
-      id: 'msg_1',
-      role: 'user',
-      content: 'Hello!',
-      timestamp: Date.now(),
-    });
-
-    expect(response.content).toBe('Hi there!');
-  });
-});
+import { describe, it, expect } from 'vitest';
+import { BaseAgent } from '../src/core/agent';
+
+describe('BaseAgent', () => {
+  it('should start in init state', () => {
+    const agent = new BaseAgent({ name: 'test' });
+    expect(agent.state).toBe('init');
+    expect(agent.name).toBe('test');
+  });
+
+  it('should transition through lifecycle', async () => {
+    const agent = new BaseAgent({ name: 'test' });
+    const states: string[] = [];
+    agent.on('state:change', (_from, to) => states.push(to));
+
+    await agent.init();
+    expect(agent.state).toBe('ready');
+
+    await agent.start();
+    expect(agent.state).toBe('running');
+
+    await agent.stop();
+    expect(agent.state).toBe('stopped');
+
+    expect(states).toEqual(['ready', 'running', 'stopped']);
+  });
+
+  it('should not start if not ready', async () => {
+    const agent = new BaseAgent({ name: 'test' });
+    await expect(agent.start()).rejects.toThrow('Cannot start agent in state: init');
+  });
+
+  it('should handle messages with stub provider', async () => {
+    const agent = new BaseAgent({ name: 'test', systemPrompt: 'Be helpful' });
+    await agent.init();
+
+    const response = await agent.handleMessage({
+      id: 'msg_1',
+      role: 'user',
+      content: 'Hello',
+      timestamp: Date.now(),
+    });
+
+    expect(response.role).toBe('assistant');
+    expect(response.content).toContain('Hello');
+  });
+
+  it('should use skills before LLM fallback', async () => {
+    const agent = new BaseAgent({ name: 'test' });
+    await agent.init();
+
+    agent.registerSkill({
+      name: 'greeter',
+      description: 'Greets users',
+      execute: async (_ctx, msg) => {
+        if (msg.content.toLowerCase().includes('hello')) {
+          return { handled: true, response: 'Hi there!', confidence: 1.0 };
+        }
+        return { handled: false, confidence: 0 };
+      },
+    });
+
+    const response = await agent.handleMessage({
+      id: 'msg_1',
+      role: 'user',
+      content: 'Hello!',
+      timestamp: Date.now(),
+    });
+
+    expect(response.content).toBe('Hi there!');
+  });
+});

package/tests/analytics.test.ts

@@ -1,50 +1,50 @@
-import { describe, it, expect } from 'vitest';
-import { Analytics } from '../src/analytics';
-
-describe('Analytics', () => {
-  it('should track messages', () => {
-    const analytics = new Analytics();
-    analytics.recordMessage(100);
-    analytics.recordMessage(200);
-    const snap = analytics.getSnapshot();
-    expect(snap.messagesProcessed).toBe(2);
-    expect(snap.avgResponseTimeMs).toBe(150);
-  });
-
-  it('should track skill usage', () => {
-    const analytics = new Analytics();
-    analytics.recordSkillUsage('faq');
-    analytics.recordSkillUsage('faq');
-    analytics.recordSkillUsage('handoff');
-    const snap = analytics.getSnapshot();
-    expect(snap.skillUsage['faq']).toBe(2);
-    expect(snap.skillUsage['handoff']).toBe(1);
-  });
-
-  it('should track errors', () => {
-    const analytics = new Analytics();
-    analytics.recordError();
-    analytics.recordError();
-    expect(analytics.getSnapshot().errorCount).toBe(2);
-  });
-
-  it('should track token usage', () => {
-    const analytics = new Analytics();
-    analytics.recordTokens(100, 50);
-    analytics.recordTokens(200, 100);
-    const snap = analytics.getSnapshot();
-    expect(snap.tokenUsage.input).toBe(300);
-    expect(snap.tokenUsage.output).toBe(150);
-    expect(snap.tokenUsage.total).toBe(450);
-  });
-
-  it('should reset analytics', () => {
-    const analytics = new Analytics();
-    analytics.recordMessage(100);
-    analytics.recordError();
-    analytics.reset();
-    const snap = analytics.getSnapshot();
-    expect(snap.messagesProcessed).toBe(0);
-    expect(snap.errorCount).toBe(0);
-  });
-});
+import { describe, it, expect } from 'vitest';
+import { Analytics } from '../src/analytics';
+
+describe('Analytics', () => {
+  it('should track messages', () => {
+    const analytics = new Analytics();
+    analytics.recordMessage(100);
+    analytics.recordMessage(200);
+    const snap = analytics.getSnapshot();
+    expect(snap.messagesProcessed).toBe(2);
+    expect(snap.avgResponseTimeMs).toBe(150);
+  });
+
+  it('should track skill usage', () => {
+    const analytics = new Analytics();
+    analytics.recordSkillUsage('faq');
+    analytics.recordSkillUsage('faq');
+    analytics.recordSkillUsage('handoff');
+    const snap = analytics.getSnapshot();
+    expect(snap.skillUsage['faq']).toBe(2);
+    expect(snap.skillUsage['handoff']).toBe(1);
+  });
+
+  it('should track errors', () => {
+    const analytics = new Analytics();
+    analytics.recordError();
+    analytics.recordError();
+    expect(analytics.getSnapshot().errorCount).toBe(2);
+  });
+
+  it('should track token usage', () => {
+    const analytics = new Analytics();
+    analytics.recordTokens(100, 50);
+    analytics.recordTokens(200, 100);
+    const snap = analytics.getSnapshot();
+    expect(snap.tokenUsage.input).toBe(300);
+    expect(snap.tokenUsage.output).toBe(150);
+    expect(snap.tokenUsage.total).toBe(450);
+  });
+
+  it('should reset analytics', () => {
+    const analytics = new Analytics();
+    analytics.recordMessage(100);
+    analytics.recordError();
+    analytics.reset();
+    const snap = analytics.getSnapshot();
+    expect(snap.messagesProcessed).toBe(0);
+    expect(snap.errorCount).toBe(0);
+  });
+});

package/tests/auto-learn.test.ts

@@ -0,0 +1,105 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { SkillLearner, skillToMarkdown, parseSkillMarkdown, type LearnedSkill } from '../src/skills/auto-learn';
+
+function makeSkill(overrides: Partial<LearnedSkill> = {}): LearnedSkill {
+  return {
+    name: 'test-skill',
+    description: 'A test skill',
+    trigger: 'deploy|deployment',
+    instructions: '1. Check env\n2. Run deploy\n3. Verify',
+    examples: ['deploy to production', 'run deployment'],
+    createdAt: new Date('2026-01-01T00:00:00Z'),
+    usageCount: 0,
+    version: 1,
+    ...overrides,
+  };
+}
+
+describe('SkillLearner', () => {
+  let tmpDir: string;
+  let learner: SkillLearner;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'opc-skills-'));
+    learner = new SkillLearner(tmpDir);
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  describe('saveSkill / loadLearnedSkills', () => {
+    it('should save and load a skill', async () => {
+      const skill = makeSkill();
+      await learner.saveSkill(skill);
+
+      const loaded = await learner.loadLearnedSkills();
+      expect(loaded).toHaveLength(1);
+      expect(loaded[0].name).toBe('test-skill');
+      expect(loaded[0].description).toBe('A test skill');
+      expect(loaded[0].trigger).toBe('deploy|deployment');
+      expect(loaded[0].examples).toEqual(['deploy to production', 'run deployment']);
+    });
+
+    it('should create directory if not exists', async () => {
+      const nested = path.join(tmpDir, 'deep', 'nested');
+      const l = new SkillLearner(nested);
+      await l.saveSkill(makeSkill());
+      expect(fs.existsSync(path.join(nested, 'test-skill.md'))).toBe(true);
+    });
+
+    it('should return empty array for nonexistent dir', async () => {
+      const l = new SkillLearner(path.join(tmpDir, 'nope'));
+      const skills = await l.loadLearnedSkills();
+      expect(skills).toEqual([]);
+    });
+  });
+
+  describe('matchSkill', () => {
+    it('should match by regex pattern', async () => {
+      await learner.saveSkill(makeSkill({ trigger: 'deploy|deployment' }));
+      await learner.loadLearnedSkills();
+
+      expect(learner.matchSkill('please deploy to production')).not.toBeNull();
+      expect(learner.matchSkill('run deployment now')).not.toBeNull();
+      expect(learner.matchSkill('hello world')).toBeNull();
+    });
+
+    it('should match by keyword fallback for invalid regex', async () => {
+      // Use an actually invalid regex so the catch branch is triggered
+      await learner.saveSkill(makeSkill({ trigger: '(deploy[broken, kubernetes' }));
+      await learner.loadLearnedSkills();
+
+      expect(learner.matchSkill('kubernetes cluster')).not.toBeNull();
+      expect(learner.matchSkill('random text')).toBeNull();
+    });
+
+    it('should return null if not loaded', () => {
+      expect(learner.matchSkill('deploy')).toBeNull();
+    });
+  });
+
+  describe('skillToMarkdown / parseSkillMarkdown', () => {
+    it('should round-trip a skill through markdown', () => {
+      const skill = makeSkill();
+      const md = skillToMarkdown(skill);
+      const parsed = parseSkillMarkdown(md);
+
+      expect(parsed).not.toBeNull();
+      expect(parsed!.name).toBe(skill.name);
+      expect(parsed!.description).toBe(skill.description);
+      expect(parsed!.trigger).toBe(skill.trigger);
+      expect(parsed!.instructions).toBe(skill.instructions);
+      expect(parsed!.examples).toEqual(skill.examples);
+      expect(parsed!.version).toBe(1);
+      expect(parsed!.usageCount).toBe(0);
+    });
+
+    it('should return null for invalid markdown', () => {
+      expect(parseSkillMarkdown('just some text')).toBeNull();
+    });
+  });
+});

package/tests/builtin-tools.test.ts

@@ -0,0 +1,83 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { mkdtempSync, rmSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { getBuiltinTools, getBuiltinToolsByName } from '../src/tools/builtin';
+import { fileTool, shellTool, datetimeTool } from '../src/tools/builtin';
+
+describe('getBuiltinTools', () => {
+  it('returns 4 tools', () => {
+    const tools = getBuiltinTools();
+    expect(tools).toHaveLength(4);
+    const names = tools.map(t => t.name);
+    expect(names).toContain('file_operations');
+    expect(names).toContain('web_fetch');
+    expect(names).toContain('shell_exec');
+    expect(names).toContain('datetime');
+  });
+
+  it('getBuiltinToolsByName filters correctly', () => {
+    const tools = getBuiltinToolsByName(['datetime', 'file_operations']);
+    expect(tools).toHaveLength(2);
+  });
+
+  it('getBuiltinToolsByName with no args returns all', () => {
+    expect(getBuiltinToolsByName()).toHaveLength(4);
+  });
+});
+
+describe('file_operations tool', () => {
+  // file tool resolves paths relative to cwd, so use relative paths from a temp dir
+  // Actually, it uses process.cwd() as workspace. Let's just test with paths relative to cwd.
+  const testFile = `tmp-test-${Date.now()}.txt`;
+
+  afterAll(() => {
+    try { require('fs').unlinkSync(testFile); } catch {}
+  });
+
+  it('write and read a file', async () => {
+    const writeRes = await fileTool.execute({ action: 'write', path: testFile, content: 'hello' });
+    expect(writeRes.isError).toBe(false);
+
+    const readRes = await fileTool.execute({ action: 'read', path: testFile });
+    expect(readRes.isError).toBe(false);
+    expect(readRes.content).toBe('hello');
+  });
+
+  it('list files', async () => {
+    const res = await fileTool.execute({ action: 'list', path: '.' });
+    expect(res.isError).toBe(false);
+    expect(res.content).toContain('package.json');
+  });
+
+  it('exists check', async () => {
+    const res = await fileTool.execute({ action: 'exists', path: testFile });
+    expect(res.content).toBe('true');
+
+    const res2 = await fileTool.execute({ action: 'exists', path: 'nope-does-not-exist.txt' });
+    expect(res2.content).toBe('false');
+  });
+
+  it('rejects path outside workspace', async () => {
+    const res = await fileTool.execute({ action: 'read', path: '../../etc/passwd' });
+    expect(res.isError).toBe(true);
+  });
+});
+
+describe('datetime tool', () => {
+  it('returns valid JSON with iso field', async () => {
+    const res = await datetimeTool.execute({});
+    expect(res.isError).toBe(false);
+    const parsed = JSON.parse(res.content);
+    expect(parsed.iso).toBeDefined();
+    expect(new Date(parsed.iso).toISOString()).toBe(parsed.iso);
+  });
+});
+
+describe('shell_exec tool', () => {
+  it('runs a command', async () => {
+    const res = await shellTool.execute({ command: 'echo hello' });
+    expect(res.isError).toBe(false);
+    expect(res.content).toContain('hello');
+  });
+});