opc-agent 4.1.1 → 4.1.3

package/tests/hooks.test.ts

@@ -1,79 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { HookManager, ALL_HOOK_EVENTS } from '../src/core/hooks';
-import type { HookContext, HookEvent } from '../src/core/hooks';
-
-describe('HookManager', () => {
-  it('should have 14 hook events defined', () => {
-    // 7 before/after pairs (message/tool/llm/send/learn/recall) = 12 + on:error/start/stop = 15
-    expect(ALL_HOOK_EVENTS.length).toBe(15);
-  });
-
-  it('should register and run hooks', async () => {
-    const mgr = new HookManager();
-    let called = false;
-    mgr.register('before:message', () => { called = true; });
-    await mgr.run('before:message');
-    expect(called).toBe(true);
-  });
-
-  it('should run hooks in priority order', async () => {
-    const mgr = new HookManager();
-    const order: number[] = [];
-    mgr.register('before:tool', () => { order.push(2); }, { priority: 200 });
-    mgr.register('before:tool', () => { order.push(1); }, { priority: 50 });
-    mgr.register('before:tool', () => { order.push(3); }, { priority: 300 });
-    await mgr.run('before:tool');
-    expect(order).toEqual([1, 2, 3]);
-  });
-
-  it('should allow context modification', async () => {
-    const mgr = new HookManager();
-    mgr.register('before:llm', (ctx) => ({ ...ctx, modified: true }));
-    mgr.register('before:llm', (ctx) => ({ ...ctx, extra: 'data' }));
-    const result = await mgr.run('before:llm', { original: true });
-    expect(result.original).toBe(true);
-    expect(result.modified).toBe(true);
-    expect(result.extra).toBe('data');
-  });
-
-  it('should unregister hooks', async () => {
-    const mgr = new HookManager();
-    let count = 0;
-    const id = mgr.register('after:message', () => { count++; });
-    await mgr.run('after:message');
-    expect(count).toBe(1);
-    expect(mgr.unregister(id)).toBe(true);
-    await mgr.run('after:message');
-    expect(count).toBe(1);
-  });
-
-  it('should list registered hooks', () => {
-    const mgr = new HookManager();
-    mgr.register('on:error', () => {}, { name: 'error-logger', priority: 10 });
-    const list = mgr.getRegistered('on:error');
-    expect(list).toHaveLength(1);
-    expect(list[0].name).toBe('error-logger');
-    expect(list[0].priority).toBe(10);
-  });
-
-  it('should clear hooks', () => {
-    const mgr = new HookManager();
-    mgr.register('on:start', () => {});
-    mgr.register('on:stop', () => {});
-    mgr.clear('on:start');
-    expect(mgr.hasHooks('on:start')).toBe(false);
-    expect(mgr.hasHooks('on:stop')).toBe(true);
-    mgr.clear();
-    expect(mgr.hasHooks('on:stop')).toBe(false);
-  });
-
-  it('should handle async hooks', async () => {
-    const mgr = new HookManager();
-    mgr.register('before:send', async (ctx) => {
-      await new Promise(r => setTimeout(r, 5));
-      return { ...ctx, async: true };
-    });
-    const result = await mgr.run('before:send', {});
-    expect(result.async).toBe(true);
-  });
-});

package/tests/i18n.test.ts

@@ -1,41 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { t, setLocale, getLocale, detectLocale, addMessages } from '../src/i18n';
-
-describe('i18n', () => {
-  it('should return English messages by default', () => {
-    setLocale('en');
-    expect(t('agent.greeting')).toBe('Hello! How can I help you?');
-  });
-
-  it('should return Chinese messages', () => {
-    setLocale('zh-CN');
-    expect(t('agent.greeting')).toBe('你好！有什么可以帮你的？');
-    setLocale('en'); // reset
-  });
-
-  it('should interpolate params', () => {
-    setLocale('en');
-    expect(t('agent.started', { name: 'TestBot' })).toBe('Agent "TestBot" started successfully');
-  });
-
-  it('should fall back to key if not found', () => {
-    expect(t('nonexistent.key')).toBe('nonexistent.key');
-  });
-
-  it('should get and set locale', () => {
-    setLocale('zh-CN');
-    expect(getLocale()).toBe('zh-CN');
-    setLocale('en');
-    expect(getLocale()).toBe('en');
-  });
-
-  it('should add custom messages', () => {
-    addMessages('en', { 'custom.key': 'Custom value' });
-    expect(t('custom.key')).toBe('Custom value');
-  });
-
-  it('should detect locale from environment', () => {
-    const locale = detectLocale();
-    expect(['en', 'zh-CN']).toContain(locale);
-  });
-});

package/tests/ide-bridge.test.ts

@@ -1,38 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { IDEBridge } from '../src/core/ide-bridge';
-
-describe('IDEBridge', () => {
-  it('should create with vscode config', () => {
-    const bridge = new IDEBridge({ editor: 'vscode' });
-    expect(bridge).toBeInstanceOf(IDEBridge);
-  });
-
-  it('should create with jetbrains config', () => {
-    const bridge = new IDEBridge({ editor: 'jetbrains', workspacePath: '/tmp' });
-    expect(bridge).toBeInstanceOf(IDEBridge);
-  });
-
-  it('getDiagnostics returns empty array (stub)', async () => {
-    const bridge = new IDEBridge({ editor: 'vscode' });
-    const diags = await bridge.getDiagnostics();
-    expect(diags).toEqual([]);
-  });
-
-  it('getOpenFiles returns empty array (stub)', async () => {
-    const bridge = new IDEBridge({ editor: 'zed' });
-    const files = await bridge.getOpenFiles();
-    expect(files).toEqual([]);
-  });
-
-  it('getSelection returns null (stub)', async () => {
-    const bridge = new IDEBridge({ editor: 'cursor' });
-    const sel = await bridge.getSelection();
-    expect(sel).toBeNull();
-  });
-
-  it('applyEdit throws for non-empty edits (stub)', async () => {
-    const bridge = new IDEBridge({ editor: 'vscode' });
-    await expect(bridge.applyEdit('test.ts', [{ range: { startLine: 1, startColumn: 0, endLine: 1, endColumn: 5 }, newText: 'hi' }]))
-      .rejects.toThrow('extension');
-  });
-});

package/tests/image-generator.test.ts

@@ -1,84 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { ImageGenerator } from '../src/tools/image-generator';
-
-describe('ImageGenerator', () => {
-  describe('detectProvider', () => {
-    it('returns null when no keys configured', () => {
-      const gen = new ImageGenerator({});
-      expect(gen.detectProvider()).toBeNull();
-    });
-
-    it('detects dalle when openai key set', () => {
-      const gen = new ImageGenerator({ openaiApiKey: 'sk-test' });
-      expect(gen.detectProvider()).toBe('dalle');
-    });
-
-    it('detects stable-diffusion when SD URL set', () => {
-      const gen = new ImageGenerator({ sdApiUrl: 'http://localhost:7860' });
-      expect(gen.detectProvider()).toBe('stable-diffusion');
-    });
-
-    it('detects replicate when token set', () => {
-      const gen = new ImageGenerator({ replicateApiKey: 'r8_test' });
-      expect(gen.detectProvider()).toBe('replicate');
-    });
-
-    it('prefers dalle over others', () => {
-      const gen = new ImageGenerator({ openaiApiKey: 'sk-test', sdApiUrl: 'http://localhost:7860' });
-      expect(gen.detectProvider()).toBe('dalle');
-    });
-  });
-
-  describe('getStatus', () => {
-    it('returns provider status', () => {
-      const gen = new ImageGenerator({ openaiApiKey: 'sk-test' });
-      const status = gen.getStatus();
-      expect(status.configured).toBe(true);
-      expect(status.providers).toHaveLength(3);
-      expect(status.providers.find(p => p.name === 'dalle')?.configured).toBe(true);
-    });
-
-    it('shows unconfigured when no keys', () => {
-      const gen = new ImageGenerator({});
-      const status = gen.getStatus();
-      expect(status.configured).toBe(false);
-    });
-  });
-
-  describe('generate', () => {
-    it('returns error when no provider configured', async () => {
-      const gen = new ImageGenerator({});
-      const result = await gen.generate('a cat');
-      expect(result.success).toBe(false);
-      expect(result.error).toContain('No image generation provider configured');
-    });
-
-    it('returns error for unknown provider', async () => {
-      const gen = new ImageGenerator({});
-      const result = await gen.generate('a cat', { provider: 'unknown' });
-      expect(result.success).toBe(false);
-      expect(result.error).toContain('Unknown provider');
-    });
-
-    it('returns error when dalle key missing', async () => {
-      const gen = new ImageGenerator({});
-      const result = await gen.generate('a cat', { provider: 'dalle' });
-      expect(result.success).toBe(false);
-      expect(result.error).toContain('OPENAI_API_KEY');
-    });
-
-    it('returns error when SD URL missing', async () => {
-      const gen = new ImageGenerator({});
-      const result = await gen.generate('a cat', { provider: 'stable-diffusion' });
-      expect(result.success).toBe(false);
-      expect(result.error).toContain('SD_API_URL');
-    });
-
-    it('returns error when replicate key missing', async () => {
-      const gen = new ImageGenerator({});
-      const result = await gen.generate('a cat', { provider: 'replicate' });
-      expect(result.success).toBe(false);
-      expect(result.error).toContain('REPLICATE_API_TOKEN');
-    });
-  });
-});

package/tests/init-role.test.ts

@@ -1,124 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import * as fs from 'fs';
-import * as path from 'path';
-import { execSync } from 'child_process';
-import { searchRoles, getPopularRoles, getRole, getCategories } from 'agent-workstation';
-
-const CLI_PATH = path.join(__dirname, '..', 'dist', 'cli.js');
-const TMP_DIR = path.join(process.env.TEMP || require('os').tmpdir(), 'opc-test-init-role-' + process.pid);
-
-function run(args: string): string {
-  return execSync(`node "${CLI_PATH}" ${args}`, { cwd: TMP_DIR, encoding: 'utf-8', timeout: 15000 });
-}
-
-describe('opc init --role integration with agent-workstation', () => {
-  beforeEach(() => {
-    if (fs.existsSync(TMP_DIR)) fs.rmSync(TMP_DIR, { recursive: true, force: true });
-    fs.mkdirSync(TMP_DIR, { recursive: true });
-  });
-
-  afterEach(() => {
-    if (fs.existsSync(TMP_DIR)) fs.rmSync(TMP_DIR, { recursive: true, force: true });
-  });
-
-  // --- agent-workstation API tests ---
-
-  it('searchRoles returns results for "customer"', () => {
-    const results = searchRoles('customer');
-    expect(results.length).toBeGreaterThan(0);
-    expect(results[0].category).toBe('customer-service');
-  });
-
-  it('searchRoles returns results for "developer"', () => {
-    const results = searchRoles('developer');
-    expect(results.length).toBeGreaterThan(0);
-    expect(results.some((r: any) => r.role.includes('developer'))).toBe(true);
-  });
-
-  it('searchRoles returns empty for nonexistent role', () => {
-    const results = searchRoles('xyznonexistentrole12345');
-    expect(results.length).toBe(0);
-  });
-
-  it('getPopularRoles returns roles with category and role fields', () => {
-    const roles = getPopularRoles();
-    expect(roles.length).toBeGreaterThan(5);
-    for (const r of roles) {
-      expect(r).toHaveProperty('category');
-      expect(r).toHaveProperty('role');
-    }
-  });
-
-  it('getRole loads full role data with files', () => {
-    const role = getRole('customer-service', 'customer-service-rep');
-    expect(role).toBeTruthy();
-    expect(role.files).toBeTruthy();
-    expect(role.files['system-prompt.md']).toBeTruthy();
-    expect(role.files['brain-seed.md']).toBeTruthy();
-  });
-
-  it('getCategories returns category list', () => {
-    const cats = getCategories();
-    expect(cats.length).toBeGreaterThan(3);
-    expect(cats.some((c: any) => c.name === 'customer-service')).toBe(true);
-  });
-
-  // --- CLI integration tests ---
-
-  it('--list-roles shows available roles', () => {
-    const output = run('init --list-roles');
-    expect(output).toContain('Available workstation roles');
-    expect(output).toContain('customer-service');
-    expect(output).toContain('--role');
-  });
-
-  it('--role customer-service generates SOUL.md from template', () => {
-    const output = run('init test-cs-agent --role customer-service');
-    expect(output).toContain('customer-service');
-    const soulPath = path.join(TMP_DIR, 'test-cs-agent', 'SOUL.md');
-    expect(fs.existsSync(soulPath)).toBe(true);
-    const soul = fs.readFileSync(soulPath, 'utf-8');
-    expect(soul).toContain('Customer Service');
-    expect(soul.split('\n').length).toBeGreaterThan(10);
-  });
-
-  it('--role generates agent.yaml with role systemPrompt', () => {
-    run('init test-yaml-agent --role customer-service');
-    const agentYaml = fs.readFileSync(path.join(TMP_DIR, 'test-yaml-agent', 'agent.yaml'), 'utf-8');
-    expect(agentYaml).toContain('Customer Service');
-    expect(agentYaml).toContain('systemPrompt');
-    expect(agentYaml).toContain('deepbrain');
-  });
-
-  it('--role generates brain-seed when available', () => {
-    run('init test-brain-agent --role customer-service');
-    const brainPath = path.join(TMP_DIR, 'test-brain-agent', 'data', 'brain-seed.md');
-    expect(fs.existsSync(brainPath)).toBe(true);
-    const brain = fs.readFileSync(brainPath, 'utf-8');
-    expect(brain.length).toBeGreaterThan(50);
-  });
-
-  it('--role generates CONTEXT.md with role info', () => {
-    run('init test-ctx-agent --role customer-service');
-    const ctx = fs.readFileSync(path.join(TMP_DIR, 'test-ctx-agent', 'CONTEXT.md'), 'utf-8');
-    expect(ctx).toContain('Customer Service');
-  });
-
-  it('--role with unknown role gives error', () => {
-    expect(() => run('init test-bad --role xyznonexistent123')).toThrow();
-  });
-
-  it('--role with partial match "developer" works', () => {
-    const output = run('init test-dev-agent --role developer');
-    expect(output).toContain('developer');
-    expect(fs.existsSync(path.join(TMP_DIR, 'test-dev-agent', 'SOUL.md'))).toBe(true);
-  });
-
-  it('init without --role still works (generic project)', () => {
-    const output = run('init test-generic -y');
-    expect(output).toContain('Created agent project');
-    expect(output).toContain('Tip');
-    expect(output).toContain('--role');
-    expect(fs.existsSync(path.join(TMP_DIR, 'test-generic', 'SOUL.md'))).toBe(true);
-  });
-});

package/tests/integrations.test.ts

@@ -1,249 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import {
-  getAllIntegrationTools, getIntegrationTool,
-  SlackTool, EmailSendTool, WebhookTool,
-  NotionTool, GitHubTool, JiraTool, CalendarTool, TrelloTool,
-  WebSearchTool, WebScraperTool, DatabaseTool, VectorSearchTool,
-  CodeExecutionTool, GitTool, NpmTool,
-  ImageGenerationTool, PDFReaderTool, CSVAnalyzerTool,
-  SummarizerTool, TranslatorTool,
-} from '../src/tools/integrations';
-
-describe('Integration Tools Registry', () => {
-  it('should return all 20 tools', () => {
-    const tools = getAllIntegrationTools();
-    expect(tools).toHaveLength(20);
-  });
-
-  it('should find tools by name', () => {
-    expect(getIntegrationTool('slack')).toBe(SlackTool);
-    expect(getIntegrationTool('github')).toBe(GitHubTool);
-    expect(getIntegrationTool('nonexistent')).toBeUndefined();
-  });
-
-  it('each tool has required properties', () => {
-    const tools = getAllIntegrationTools();
-    for (const tool of tools) {
-      expect(tool.name).toBeTruthy();
-      expect(tool.description).toBeTruthy();
-      expect(tool.inputSchema).toBeDefined();
-      expect(typeof tool.execute).toBe('function');
-    }
-  });
-
-  it('all tool names are unique', () => {
-    const tools = getAllIntegrationTools();
-    const names = tools.map((t) => t.name);
-    expect(new Set(names).size).toBe(names.length);
-  });
-});
-
-describe('SlackTool', () => {
-  it('should require action', async () => {
-    const r = await SlackTool.execute({});
-    expect(r.content).toContain('Unknown action');
-  });
-
-  it('should require text for send_message', async () => {
-    const r = await SlackTool.execute({ action: 'send_message' });
-    expect(r.isError).toBe(true);
-    expect(r.content).toContain('text is required');
-  });
-});
-
-describe('EmailSendTool', () => {
-  it('should require SMTP env vars', async () => {
-    const r = await EmailSendTool.execute({ to: 'a@b.com', subject: 'test', body: 'hi' });
-    expect(r.isError).toBe(true);
-    expect(r.content).toContain('SMTP_HOST');
-  });
-});
-
-describe('WebhookTool', () => {
-  it('should require url', async () => {
-    const r = await WebhookTool.execute({});
-    expect(r.isError).toBe(true);
-    expect(r.content).toContain('url is required');
-  });
-});
-
-describe('NotionTool', () => {
-  it('should require API key', async () => {
-    const r = await NotionTool.execute({ action: 'search', query: 'test' });
-    expect(r.isError).toBe(true);
-    expect(r.content).toContain('NOTION_API_KEY');
-  });
-});
-
-describe('GitHubTool', () => {
-  it('should require GITHUB_TOKEN', async () => {
-    const r = await GitHubTool.execute({ action: 'list_issues', owner: 'a', repo: 'b' });
-    expect(r.isError).toBe(true);
-    expect(r.content).toContain('GITHUB_TOKEN');
-  });
-
-  it('should validate create_issue params', async () => {
-    process.env.GITHUB_TOKEN = 'test';
-    const r = await GitHubTool.execute({ action: 'create_issue' });
-    expect(r.isError).toBe(true);
-    expect(r.content).toContain('owner, repo, title required');
-    delete process.env.GITHUB_TOKEN;
-  });
-});
-
-describe('JiraTool', () => {
-  it('should require Jira env vars', async () => {
-    const r = await JiraTool.execute({ action: 'search', jql: 'test' });
-    expect(r.isError).toBe(true);
-    expect(r.content).toContain('JIRA_URL');
-  });
-});
-
-describe('CalendarTool', () => {
-  it('should require GOOGLE_ACCESS_TOKEN', async () => {
-    const r = await CalendarTool.execute({ action: 'list_events' });
-    expect(r.isError).toBe(true);
-    expect(r.content).toContain('GOOGLE_ACCESS_TOKEN');
-  });
-});
-
-describe('TrelloTool', () => {
-  it('should require API key and token', async () => {
-    const r = await TrelloTool.execute({ action: 'list_boards' });
-    expect(r.isError).toBe(true);
-    expect(r.content).toContain('TRELLO_API_KEY');
-  });
-});
-
-describe('WebSearchTool', () => {
-  it('should require query', async () => {
-    const r = await WebSearchTool.execute({});
-    expect(r.isError).toBe(true);
-    expect(r.content).toContain('query required');
-  });
-
-  it('should require API key', async () => {
-    const r = await WebSearchTool.execute({ query: 'test' });
-    expect(r.isError).toBe(true);
-    expect(r.content).toContain('No search API key');
-  });
-});
-
-describe('WebScraperTool', () => {
-  it('should require url', async () => {
-    const r = await WebScraperTool.execute({});
-    expect(r.isError).toBe(true);
-    expect(r.content).toContain('url required');
-  });
-});
-
-describe('DatabaseTool', () => {
-  it('should require connection URL', async () => {
-    const r = await DatabaseTool.execute({ query: 'SELECT 1' });
-    expect(r.isError).toBe(true);
-    expect(r.content).toContain('DATABASE_URL');
-  });
-
-  it('should block destructive queries by default', async () => {
-    process.env.DATABASE_URL = 'test.db';
-    const r = await DatabaseTool.execute({ query: 'DROP TABLE users' });
-    expect(r.isError).toBe(true);
-    expect(r.content).toContain('Destructive queries blocked');
-    delete process.env.DATABASE_URL;
-  });
-});
-
-describe('VectorSearchTool', () => {
-  it('should require DEEPBRAIN_URL', async () => {
-    const r = await VectorSearchTool.execute({ query: 'test' });
-    expect(r.isError).toBe(true);
-    expect(r.content).toContain('DEEPBRAIN_URL');
-  });
-});
-
-describe('CodeExecutionTool', () => {
-  it('should require code', async () => {
-    const r = await CodeExecutionTool.execute({ language: 'javascript', code: '' });
-    expect(r.isError).toBe(true);
-    expect(r.content).toContain('code required');
-  });
-
-  it('should reject unknown language', async () => {
-    const r = await CodeExecutionTool.execute({ language: 'ruby', code: 'puts 1' });
-    expect(r.isError).toBe(true);
-    expect(r.content).toContain('Unsupported language');
-  });
-});
-
-describe('GitTool', () => {
-  it('should require message for commit', async () => {
-    const r = await GitTool.execute({ action: 'commit' });
-    expect(r.isError).toBe(true);
-    expect(r.content).toContain('message required');
-  });
-});
-
-describe('NpmTool', () => {
-  it('should reject install action', async () => {
-    const r = await NpmTool.execute({ action: 'install', package: 'lodash' });
-    expect(r.isError).toBe(true);
-    expect(r.content).toContain('not supported');
-  });
-});
-
-describe('ImageGenerationTool', () => {
-  it('should require prompt', async () => {
-    const r = await ImageGenerationTool.execute({});
-    expect(r.isError).toBe(true);
-    expect(r.content).toContain('prompt required');
-  });
-});
-
-describe('PDFReaderTool', () => {
-  it('should require file_path or url', async () => {
-    const r = await PDFReaderTool.execute({});
-    expect(r.isError).toBe(true);
-    expect(r.content).toContain('file_path or url required');
-  });
-});
-
-describe('CSVAnalyzerTool', () => {
-  it('should require file_path or data', async () => {
-    const r = await CSVAnalyzerTool.execute({});
-    expect(r.isError).toBe(true);
-    expect(r.content).toContain('file_path or data required');
-  });
-
-  it('should parse inline CSV', async () => {
-    const r = await CSVAnalyzerTool.execute({ data: 'name,age\nAlice,30\nBob,25', action: 'parse' });
-    expect(r.isError).toBeUndefined();
-    expect(r.content).toContain('2 rows');
-  });
-
-  it('should aggregate CSV', async () => {
-    const r = await CSVAnalyzerTool.execute({ data: 'name,score\nA,10\nB,20\nC,30', action: 'aggregate', column: 'score', operation: 'sum' });
-    expect(r.content).toContain('60');
-  });
-});
-
-describe('SummarizerTool', () => {
-  it('should require text', async () => {
-    const r = await SummarizerTool.execute({});
-    expect(r.isError).toBe(true);
-    expect(r.content).toContain('text required');
-  });
-
-  it('should require API key', async () => {
-    const r = await SummarizerTool.execute({ text: 'Hello world' });
-    expect(r.isError).toBe(true);
-    expect(r.content).toContain('OPENAI_API_KEY');
-  });
-});
-
-describe('TranslatorTool', () => {
-  it('should require text and target language', async () => {
-    const r = await TranslatorTool.execute({});
-    expect(r.isError).toBe(true);
-    expect(r.content).toContain('text and to are required');
-  });
-});