opc-agent 4.1.2 → 4.1.4

package/tests/settings-api.test.ts

@@ -1,148 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import * as fs from 'fs';
-import * as path from 'path';
-
-describe('Settings API & UI', () => {
-  describe('Backend - server.ts settings routes', () => {
-    const serverSrc = fs.readFileSync(path.join(__dirname, '../src/studio/server.ts'), 'utf-8');
-
-    it('has settings/models GET route', () => {
-      expect(serverSrc).toContain("route === 'settings/models' && req.method === 'GET'");
-    });
-
-    it('has settings/models PUT route', () => {
-      expect(serverSrc).toContain("route === 'settings/models' && req.method === 'PUT'");
-    });
-
-    it('has settings/models/test POST route', () => {
-      expect(serverSrc).toContain("route === 'settings/models/test' && req.method === 'POST'");
-    });
-
-    it('has settings/models/local GET route', () => {
-      expect(serverSrc).toContain("route === 'settings/models/local' && req.method === 'GET'");
-    });
-
-    it('has settings/channels GET route', () => {
-      expect(serverSrc).toContain("route === 'settings/channels' && req.method === 'GET'");
-    });
-
-    it('has settings/channels/:name PUT route', () => {
-      expect(serverSrc).toContain("settings\\/channels\\/[^/]+");
-    });
-
-    it('has settings/status GET route', () => {
-      expect(serverSrc).toContain("route === 'settings/status' && req.method === 'GET'");
-    });
-
-    it('has settings/usage GET route', () => {
-      expect(serverSrc).toContain("route === 'settings/usage' && req.method === 'GET'");
-    });
-
-    it('has detectLocalOllama method', () => {
-      expect(serverSrc).toContain('detectLocalOllama');
-    });
-
-    it('has testModelConnection method', () => {
-      expect(serverSrc).toContain('testModelConnection');
-    });
-
-    it('saves config to ~/.opc/config.json', () => {
-      expect(serverSrc).toContain("'.opc'");
-      expect(serverSrc).toContain("'config.json'");
-    });
-  });
-
-  describe('Frontend - index.html settings UI', () => {
-    const html = fs.readFileSync(path.join(__dirname, '../src/studio-ui/index.html'), 'utf-8');
-
-    it('has settings page container', () => {
-      expect(html).toContain('id="page-settings"');
-    });
-
-    it('has settings navigation items', () => {
-      expect(html).toContain('data-settings="models"');
-      expect(html).toContain('data-settings="channels"');
-      expect(html).toContain('data-settings="memory"');
-      expect(html).toContain('data-settings="role"');
-      expect(html).toContain('data-settings="status"');
-      expect(html).toContain('data-settings="usage"');
-    });
-
-    it('has models panel with local/cloud tabs', () => {
-      expect(html).toContain('id="sp-models"');
-      expect(html).toContain('id="mt-local"');
-      expect(html).toContain('id="mt-cloud"');
-    });
-
-    it('has Ollama detection UI', () => {
-      expect(html).toContain('id="ollama-status"');
-      expect(html).toContain('id="ollama-models"');
-      expect(html).toContain('id="ollama-tutorial"');
-      expect(html).toContain('ollama.com');
-    });
-
-    it('has cloud provider cards', () => {
-      expect(html).toContain('pv-openai');
-      expect(html).toContain('pv-deepseek');
-      expect(html).toContain('pv-anthropic');
-    });
-
-    it('has model assignment dropdowns', () => {
-      expect(html).toContain('id="cfg-chat-model"');
-      expect(html).toContain('id="cfg-embed-model"');
-      expect(html).toContain('qwen2.5:7b');
-      expect(html).toContain('nomic-embed-text');
-    });
-
-    it('has channels panel', () => {
-      expect(html).toContain('id="sp-channels"');
-      expect(html).toContain('id="channels-grid"');
-    });
-
-    it('has memory panel with DeepBrain iframe reference', () => {
-      expect(html).toContain('id="sp-memory"');
-      expect(html).toContain('localhost:4001');
-      expect(html).toContain('DeepBrain');
-    });
-
-    it('has role panel with Workstation iframe reference', () => {
-      expect(html).toContain('id="sp-role"');
-      expect(html).toContain('localhost:4003');
-      expect(html).toContain('Workstation');
-    });
-
-    it('has status panel with logs viewer', () => {
-      expect(html).toContain('id="sp-status"');
-      expect(html).toContain('id="status-logs"');
-    });
-
-    it('has usage panel', () => {
-      expect(html).toContain('id="sp-usage"');
-      expect(html).toContain('id="usage-stats"');
-    });
-
-    it('has provider config dialog', () => {
-      expect(html).toContain('id="provider-dialog"');
-      expect(html).toContain('id="pd-apikey"');
-      expect(html).toContain('testProvider');
-    });
-
-    it('has channel config dialog', () => {
-      expect(html).toContain('id="channel-dialog"');
-    });
-
-    it('has settings nav in sidebar', () => {
-      expect(html).toContain('data-page="settings"');
-      expect(html).toContain('Settings');
-    });
-
-    it('has Chinese-friendly copy', () => {
-      expect(html).toContain('模型配置');
-      expect(html).toContain('渠道配置');
-      expect(html).toContain('记忆管理');
-      expect(html).toContain('角色编辑');
-      expect(html).toContain('运行状态');
-      expect(html).toContain('用量统计');
-    });
-  });
-});

package/tests/setup.test.ts

@@ -1,73 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { Readable, Writable } from 'stream';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-
-// Mock http to control Ollama detection
-vi.mock('http', async () => {
-  const actual = await vi.importActual<typeof import('http')>('http');
-  return { ...actual };
-});
-
-describe('setup wizard', () => {
-  const OPC_HOME = path.join(os.tmpdir(), `.opc-test-${Date.now()}`);
-  const CONFIG_PATH = path.join(OPC_HOME, 'config.json');
-
-  beforeEach(() => {
-    // Override HOME so setup writes to temp
-    vi.stubEnv('HOME', os.tmpdir());
-    fs.mkdirSync(OPC_HOME, { recursive: true });
-  });
-
-  afterEach(() => {
-    fs.rmSync(OPC_HOME, { recursive: true, force: true });
-    vi.unstubAllEnvs();
-  });
-
-  function createMockInput(lines: string[]): Readable {
-    const input = new Readable({ read() {} });
-    // Push lines async to simulate user typing
-    let i = 0;
-    const interval = setInterval(() => {
-      if (i < lines.length) {
-        input.push(lines[i] + '\n');
-        i++;
-      } else {
-        input.push(null);
-        clearInterval(interval);
-      }
-    }, 50);
-    return input;
-  }
-
-  function createMockOutput(): Writable {
-    const chunks: Buffer[] = [];
-    const output = new Writable({
-      write(chunk, _enc, cb) { chunks.push(Buffer.from(chunk)); cb(); },
-    });
-    (output as any).getOutput = () => Buffer.concat(chunks).toString();
-    return output;
-  }
-
-  it('should export runSetup function', async () => {
-    const { runSetup } = await import('../src/cli/setup');
-    expect(typeof runSetup).toBe('function');
-  });
-
-  it('should have TEMPLATES defined', async () => {
-    // Just test that the module loads without error
-    const mod = await import('../src/cli/setup');
-    expect(mod).toBeDefined();
-  });
-
-  it('createRL should return a readline interface', async () => {
-    const { createRL } = await import('../src/cli/setup');
-    const input = new Readable({ read() {} });
-    const output = createMockOutput();
-    const rl = createRL(input, output);
-    expect(rl).toBeDefined();
-    rl.close();
-    input.destroy();
-  });
-});

package/tests/skill-learner.test.ts

@@ -1,161 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-import { SkillLearner } from '../src/skills/auto-learn';
-
-describe('SkillLearner', () => {
-  let tmpDir: string;
-  let learner: SkillLearner;
-
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'skill-learner-'));
-    learner = new SkillLearner(tmpDir);
-  });
-
-  afterEach(() => {
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  it('saveSkill creates .md file', async () => {
-    const skill = makeSkill('test-skill');
-    await learner.saveSkill(skill);
-    expect(fs.existsSync(path.join(tmpDir, 'test-skill.md'))).toBe(true);
-  });
-
-  it('loadSkills reads .md files', async () => {
-    await learner.saveSkill(makeSkill('s1'));
-    await learner.saveSkill(makeSkill('s2'));
-    const skills = await learner.loadLearnedSkills();
-    expect(skills.length).toBeGreaterThanOrEqual(2);
-  });
-
-  it('round-trip: save then load matches', async () => {
-    const skill = makeSkill('roundtrip');
-    await learner.saveSkill(skill);
-    const skills = await learner.loadLearnedSkills();
-    const found = skills.find(s => s.name === 'roundtrip');
-    expect(found).toBeDefined();
-    expect(found!.description).toBe(skill.description);
-    expect(found!.instructions).toBe(skill.instructions);
-  });
-
-  it('matchSkill with regex pattern', async () => {
-    const skill = makeSkill('deploy-app', 'deploy|release');
-    await learner.saveSkill(skill);
-    await learner.loadLearnedSkills();
-    const match = learner.matchSkill('please deploy the app');
-    expect(match).toBeDefined();
-    expect(match!.name).toBe('deploy-app');
-  });
-
-  it('matchSkill with keyword fallback', async () => {
-    const skill = makeSkill('send-email', 'send.*email');
-    skill.examples = ['send email to boss', 'email the team'];
-    await learner.saveSkill(skill);
-    await learner.loadLearnedSkills();
-    const match = learner.matchSkill('send email to the team');
-    expect(match).toBeDefined();
-  });
-
-  it('matchSkill returns null on no match', async () => {
-    const skill = makeSkill('deploy-app', 'deploy|release');
-    await learner.saveSkill(skill);
-    await learner.loadLearnedSkills();
-    const match = learner.matchSkill('what is the weather?');
-    expect(match).toBeNull();
-  });
-
-  it('empty skills dir returns empty array', async () => {
-    const skills = await learner.loadLearnedSkills();
-    expect(skills).toEqual([]);
-  });
-
-  it('special characters in skill name handled', async () => {
-    const skill = makeSkill('my-skill-v2');
-    await learner.saveSkill(skill);
-    expect(fs.existsSync(path.join(tmpDir, 'my-skill-v2.md'))).toBe(true);
-  });
-
-  it('saving same skill overwrites', async () => {
-    const skill1 = makeSkill('same');
-    await learner.saveSkill(skill1);
-    const skill2 = makeSkill('same');
-    skill2.description = 'updated description';
-    await learner.saveSkill(skill2);
-    const skills = await learner.loadLearnedSkills();
-    const found = skills.filter(s => s.name === 'same');
-    expect(found).toHaveLength(1);
-  });
-
-  it('skill version field preserved through save/load', async () => {
-    const skill = makeSkill('versioned');
-    skill.version = 3;
-    await learner.saveSkill(skill);
-    const skills = await learner.loadLearnedSkills();
-    const found = skills.find(s => s.name === 'versioned');
-    expect(found).toBeDefined();
-    expect(found!.version).toBe(3);
-  });
-
-  it('loadSkills ignores non-md files', async () => {
-    fs.writeFileSync(path.join(tmpDir, 'readme.txt'), 'not a skill');
-    const skills = await learner.loadLearnedSkills();
-    expect(skills).toHaveLength(0);
-  });
-
-  it('multiple skills: only matching one returned', async () => {
-    await learner.saveSkill(makeSkill('alpha', 'alpha|first'));
-    await learner.saveSkill(makeSkill('beta', 'beta|second'));
-    await learner.loadLearnedSkills();
-    const match = learner.matchSkill('trigger beta action');
-    expect(match).toBeDefined();
-    expect(match!.name).toBe('beta');
-  });
-
-  it('skills dir created if not exists', async () => {
-    const newDir = path.join(tmpDir, 'nested', 'skills');
-    const l2 = new SkillLearner(newDir);
-    await l2.saveSkill(makeSkill('nested'));
-    expect(fs.existsSync(path.join(newDir, 'nested.md'))).toBe(true);
-  });
-
-  it('analyzeForSkillCreation returns null with non-creating provider', async () => {
-    const mockProvider = {
-      name: 'mock',
-      chat: vi.fn().mockResolvedValue('{"shouldCreate": false, "skill": null}'),
-      chatStream: vi.fn(),
-    };
-    const result = await learner.analyzeForSkillCreation(
-      [{ id: '1', role: 'user', content: 'hello', timestamp: Date.now() }],
-      mockProvider as any,
-    );
-    expect(result).toBeNull();
-  });
-
-  it('analyzeForSkillCreation handles provider error gracefully', async () => {
-    const mockProvider = {
-      name: 'mock',
-      chat: vi.fn().mockRejectedValue(new Error('API error')),
-      chatStream: vi.fn(),
-    };
-    const result = await learner.analyzeForSkillCreation(
-      [{ id: '1', role: 'user', content: 'hello', timestamp: Date.now() }],
-      mockProvider as any,
-    );
-    expect(result).toBeNull();
-  });
-});
-
-function makeSkill(name: string, trigger = 'test', description = 'A test skill') {
-  return {
-    name,
-    description,
-    trigger,
-    instructions: 'Do the thing',
-    examples: ['example 1', 'example 2'],
-    createdAt: new Date(),
-    usageCount: 0,
-    version: 1,
-  };
-}

package/tests/streaming.test.ts

@@ -1,109 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { StreamingManager, StreamableResponse } from '../src/core/streaming';
-import type { StreamChunk } from '../src/core/streaming';
-
-describe('StreamableResponse', () => {
-  it('should collect chunks and build text', () => {
-    const stream = new StreamableResponse('test-1');
-    stream.push({ id: '0', type: 'text', data: 'Hello ', timestamp: Date.now() });
-    stream.push({ id: '1', type: 'text', data: 'World', timestamp: Date.now() });
-    expect(stream.getText()).toBe('Hello World');
-    expect(stream.length).toBe(2);
-  });
-
-  it('should emit chunk events', () => {
-    const stream = new StreamableResponse('test-2');
-    const received: StreamChunk[] = [];
-    stream.on('chunk', (c: StreamChunk) => received.push(c));
-    stream.push({ id: '0', type: 'text', data: 'hi', timestamp: Date.now() });
-    expect(received.length).toBe(1);
-  });
-
-  it('should emit end event', () => {
-    const stream = new StreamableResponse('test-3');
-    let ended = false;
-    stream.on('end', () => { ended = true; });
-    stream.end();
-    expect(ended).toBe(true);
-    expect(stream.isEnded).toBe(true);
-  });
-
-  it('should apply backpressure at highWaterMark', () => {
-    const stream = new StreamableResponse('test-4', { highWaterMark: 2 });
-    const chunk = (): StreamChunk => ({ id: 'c', type: 'text', data: 'x', timestamp: Date.now() });
-    stream.push(chunk()); // 1 — ok
-    const ok = stream.push(chunk()); // 2 — triggers backpressure
-    expect(ok).toBe(false);
-    expect(stream.isPaused).toBe(true);
-  });
-
-  it('should flush buffer on resume', () => {
-    const stream = new StreamableResponse('test-5', { highWaterMark: 1 });
-    const received: StreamChunk[] = [];
-    stream.on('chunk', (c: StreamChunk) => received.push(c));
-    stream.push({ id: '0', type: 'text', data: 'a', timestamp: Date.now() });
-    // Now paused — next chunk goes to buffer
-    stream.push({ id: '1', type: 'text', data: 'b', timestamp: Date.now() });
-    expect(received.length).toBe(1);
-    stream.resume();
-    expect(received.length).toBe(2);
-    expect(stream.isPaused).toBe(false);
-  });
-
-  it('should reject pushes after end', () => {
-    const stream = new StreamableResponse('test-6');
-    stream.end();
-    const ok = stream.push({ id: '0', type: 'text', data: 'late', timestamp: Date.now() });
-    expect(ok).toBe(false);
-    expect(stream.length).toBe(0);
-  });
-});
-
-describe('StreamingManager', () => {
-  it('should create and manage streams', () => {
-    const mgr = new StreamingManager();
-    const stream = mgr.createStream();
-    expect(stream.id).toMatch(/^stream_/);
-    expect(mgr.activeCount).toBe(1);
-  });
-
-  it('should write chunks and end stream', () => {
-    const mgr = new StreamingManager();
-    const stream = mgr.createStream();
-    mgr.writeChunk(stream.id, 'hello');
-    mgr.writeChunk(stream.id, ' world');
-    mgr.endStream(stream.id);
-    expect(stream.getText()).toBe('hello world');
-    expect(stream.isEnded).toBe(true);
-  });
-
-  it('should return false for unknown stream writes', () => {
-    const mgr = new StreamingManager();
-    expect(mgr.writeChunk('nonexistent', 'data')).toBe(false);
-  });
-
-  it('should format SSE correctly', () => {
-    const chunk: StreamChunk = { id: 'c1', type: 'text', data: 'hi', timestamp: 123 };
-    const sse = StreamingManager.formatSSE(chunk);
-    expect(sse).toContain('event: text');
-    expect(sse).toContain('id: c1');
-    expect(sse).toContain('"data":"hi"');
-  });
-
-  it('should pipe to SSE response', () => {
-    const mgr = new StreamingManager();
-    const stream = mgr.createStream();
-    const written: string[] = [];
-    const mockRes = {
-      write: (d: string) => { written.push(d); return true; },
-      end: vi.fn(),
-      setHeader: vi.fn(),
-    };
-    StreamingManager.pipeSSE(stream, mockRes, { heartbeatInterval: 100_000 });
-    mgr.writeChunk(stream.id, 'data');
-    mgr.endStream(stream.id);
-    expect(written.length).toBeGreaterThan(0);
-    expect(mockRes.end).toHaveBeenCalled();
-    expect(mockRes.setHeader).toHaveBeenCalledWith('Content-Type', 'text/event-stream');
-  });
-});