@charming_groot/agent 0.1.0

package/tests/message-manager.test.ts

@@ -0,0 +1,195 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { MessageManager } from '../src/message-manager.js';
+
+describe('MessageManager', () => {
+  let manager: MessageManager;
+
+  beforeEach(() => {
+    manager = new MessageManager();
+  });
+
+  it('should start empty', () => {
+    expect(manager.messageCount).toBe(0);
+    expect(manager.getMessages()).toEqual([]);
+  });
+
+  it('should add system message', () => {
+    manager.addSystemMessage('You are helpful.');
+    expect(manager.messageCount).toBe(1);
+    const msgs = manager.getMessages();
+    expect(msgs[0]?.role).toBe('system');
+    expect(msgs[0]?.content).toBe('You are helpful.');
+  });
+
+  it('should add user message', () => {
+    manager.addUserMessage('Hello');
+    const msgs = manager.getMessages();
+    expect(msgs[0]?.role).toBe('user');
+    expect(msgs[0]?.content).toBe('Hello');
+  });
+
+  it('should add assistant message', () => {
+    manager.addAssistantMessage('Hi there!');
+    const msgs = manager.getMessages();
+    expect(msgs[0]?.role).toBe('assistant');
+    expect(msgs[0]?.content).toBe('Hi there!');
+  });
+
+  it('should add assistant message with tool calls', () => {
+    const toolCalls = [
+      { id: 'tc-1', name: 'file_read', arguments: '{"path":"test.txt"}' },
+    ];
+    manager.addAssistantMessage('Let me read that.', toolCalls);
+    const msgs = manager.getMessages();
+    expect(msgs[0]?.toolCalls).toHaveLength(1);
+    expect(msgs[0]?.toolCalls?.[0]?.name).toBe('file_read');
+  });
+
+  it('should add tool results', () => {
+    const results = new Map([
+      ['tc-1', { success: true, output: 'file content' }],
+    ]);
+    manager.addToolResults(results);
+    const msgs = manager.getMessages();
+    expect(msgs[0]?.toolResults).toHaveLength(1);
+    expect(msgs[0]?.toolResults?.[0]?.toolCallId).toBe('tc-1');
+    expect(msgs[0]?.toolResults?.[0]?.content).toBe('file content');
+  });
+
+  it('should format error tool results', () => {
+    const results = new Map([
+      ['tc-1', { success: false, output: '', error: 'File not found' }],
+    ]);
+    manager.addToolResults(results);
+    const msgs = manager.getMessages();
+    expect(msgs[0]?.toolResults?.[0]?.content).toContain('Error: File not found');
+  });
+
+  it('should return last message', () => {
+    manager.addUserMessage('first');
+    manager.addAssistantMessage('second');
+    expect(manager.getLastMessage()?.content).toBe('second');
+  });
+
+  it('should return undefined for empty last message', () => {
+    expect(manager.getLastMessage()).toBeUndefined();
+  });
+
+  it('should clear all messages', () => {
+    manager.addUserMessage('hello');
+    manager.addAssistantMessage('hi');
+    manager.clear();
+    expect(manager.messageCount).toBe(0);
+  });
+
+  it('should not compress when under budget', () => {
+    manager.addSystemMessage('system');
+    manager.addUserMessage('hello');
+    manager.addAssistantMessage('hi');
+    const compressed = manager.compressIfNeeded();
+    expect(compressed).toBe(0);
+    expect(manager.messageCount).toBe(3);
+  });
+
+  it('should compress when over budget', () => {
+    // Use a manager with very low token limit to force compression
+    const small = new MessageManager({ maxHistoryTokens: 50, keepRecentMessages: 2 });
+    small.addSystemMessage('system');
+    // Add many messages to exceed 50 tokens
+    for (let i = 0; i < 20; i++) {
+      small.addUserMessage(`User message number ${i} with some extra content to add tokens`);
+      small.addAssistantMessage(`Response number ${i} with detailed explanation text`);
+    }
+    const before = small.messageCount;
+    const compressed = small.compressIfNeeded();
+    expect(compressed).toBeGreaterThan(0);
+    expect(small.messageCount).toBeLessThan(before);
+    // System message preserved
+    const msgs = small.getMessages();
+    expect(msgs[0]?.role).toBe('system');
+    // Summary message present
+    expect(msgs[1]?.content).toContain('Context summary');
+  });
+
+  it('should preserve system messages during compression', () => {
+    const small = new MessageManager({ maxHistoryTokens: 30, keepRecentMessages: 2 });
+    small.addSystemMessage('You are helpful.');
+    for (let i = 0; i < 15; i++) {
+      small.addUserMessage(`msg ${i} ${'x'.repeat(50)}`);
+      small.addAssistantMessage(`reply ${i} ${'y'.repeat(50)}`);
+    }
+    small.compressIfNeeded();
+    const msgs = small.getMessages();
+    expect(msgs[0]?.role).toBe('system');
+    expect(msgs[0]?.content).toBe('You are helpful.');
+  });
+
+  it('should replace existing system message with setSystemMessage', () => {
+    manager.addSystemMessage('Original prompt');
+    manager.addUserMessage('hello');
+    manager.setSystemMessage('Updated prompt');
+    const msgs = manager.getMessages();
+    expect(msgs[0]?.role).toBe('system');
+    expect(msgs[0]?.content).toBe('Updated prompt');
+    expect(manager.messageCount).toBe(2); // no extra message added
+  });
+
+  it('should insert system message at position 0 if none exists', () => {
+    manager.addUserMessage('hello');
+    manager.setSystemMessage('Injected prompt');
+    const msgs = manager.getMessages();
+    expect(msgs[0]?.role).toBe('system');
+    expect(msgs[0]?.content).toBe('Injected prompt');
+    expect(msgs[1]?.role).toBe('user');
+    expect(manager.messageCount).toBe(2);
+  });
+
+  it('should serialize and restore messages', () => {
+    manager.addSystemMessage('You are helpful.');
+    manager.addUserMessage('Hello');
+    manager.addAssistantMessage('Hi!', [
+      { id: 'tc-1', name: 'file_read', arguments: '{"path":"a.txt"}' },
+    ]);
+
+    const json = manager.serialize();
+    const restored = new MessageManager();
+    restored.restore(json);
+
+    expect(restored.messageCount).toBe(3);
+    const msgs = restored.getMessages();
+    expect(msgs[0]?.role).toBe('system');
+    expect(msgs[1]?.content).toBe('Hello');
+    expect(msgs[2]?.toolCalls?.[0]?.name).toBe('file_read');
+  });
+
+  it('should clear existing messages on restore', () => {
+    manager.addUserMessage('old');
+    manager.restore(JSON.stringify([{ role: 'user', content: 'new' }]));
+    expect(manager.messageCount).toBe(1);
+    expect(manager.getMessages()[0]?.content).toBe('new');
+  });
+
+  it('should throw on invalid serialized data', () => {
+    expect(() => manager.restore('"not an array"')).toThrow('expected an array');
+  });
+
+  it('should skip malformed entries during restore', () => {
+    const json = JSON.stringify([
+      { role: 'user', content: 'valid' },
+      { bad: 'entry' },
+      { role: 123, content: 'invalid role' },
+    ]);
+    manager.restore(json);
+    expect(manager.messageCount).toBe(1);
+    expect(manager.getMessages()[0]?.content).toBe('valid');
+  });
+
+  it('should return a copy of messages', () => {
+    manager.addUserMessage('hello');
+    const msgs = manager.getMessages();
+    expect(msgs).toHaveLength(1);
+    // Adding more shouldn't affect returned array
+    manager.addUserMessage('world');
+    expect(msgs).toHaveLength(1);
+  });
+});

package/tests/permission.test.ts

@@ -0,0 +1,148 @@
+import { describe, it, expect, vi } from 'vitest';
+import { PermissionManager } from '../src/permission.js';
+import type { ApprovalLevel } from '../src/permission.js';
+import type { ITool } from '@charming_groot/core';
+
+function createMockTool(name: string, requiresPermission: boolean): ITool {
+  return {
+    name,
+    requiresPermission,
+    describe: () => ({ name, description: '', parameters: [] }),
+    execute: async () => ({ success: true, output: '' }),
+  };
+}
+
+describe('PermissionManager', () => {
+  it('should auto-approve tools that do not require permission', async () => {
+    const manager = new PermissionManager();
+    const tool = createMockTool('file_read', false);
+    expect(await manager.checkPermission(tool)).toBe(true);
+  });
+
+  it('should auto-approve with default handler', async () => {
+    const manager = new PermissionManager();
+    const tool = createMockTool('shell_exec', true);
+    expect(await manager.checkPermission(tool)).toBe(true);
+  });
+
+  it('should pass params to handler', async () => {
+    const handler = vi.fn().mockResolvedValue('session');
+    const manager = new PermissionManager(handler);
+    const tool = createMockTool('shell_exec', true);
+    const params = { command: 'ls -la' };
+
+    await manager.checkPermission(tool, params);
+    expect(handler).toHaveBeenCalledWith('shell_exec', params);
+  });
+
+  it('should deny when handler returns false', async () => {
+    const handler = vi.fn().mockResolvedValue(false);
+    const manager = new PermissionManager(handler);
+    const tool = createMockTool('shell_exec', true);
+    expect(await manager.checkPermission(tool, { command: 'rm -rf /' })).toBe(false);
+  });
+
+  it('should deny when handler returns "deny"', async () => {
+    const handler = vi.fn().mockResolvedValue('deny' as ApprovalLevel);
+    const manager = new PermissionManager(handler);
+    const tool = createMockTool('shell_exec', true);
+    expect(await manager.checkPermission(tool)).toBe(false);
+  });
+
+  // --- Approval levels ---
+
+  it('should cache on "session" level', async () => {
+    const handler = vi.fn().mockResolvedValue('session' as ApprovalLevel);
+    const manager = new PermissionManager(handler);
+    const tool = createMockTool('shell_exec', true);
+
+    await manager.checkPermission(tool, { command: 'ls' });
+    await manager.checkPermission(tool, { command: 'pwd' });
+
+    // Handler called only once — second call uses cache
+    expect(handler).toHaveBeenCalledTimes(1);
+  });
+
+  it('should NOT cache on "once" level', async () => {
+    const handler = vi.fn().mockResolvedValue('once' as ApprovalLevel);
+    const manager = new PermissionManager(handler);
+    const tool = createMockTool('shell_exec', true);
+
+    await manager.checkPermission(tool, { command: 'ls' });
+    await manager.checkPermission(tool, { command: 'pwd' });
+
+    // Handler called every time
+    expect(handler).toHaveBeenCalledTimes(2);
+  });
+
+  it('should cache on "always" level and invoke persist callback', async () => {
+    const handler = vi.fn().mockResolvedValue('always' as ApprovalLevel);
+    const onPersist = vi.fn();
+    const manager = new PermissionManager(handler, onPersist);
+    const tool = createMockTool('shell_exec', true);
+
+    await manager.checkPermission(tool, { command: 'ls' });
+    expect(onPersist).toHaveBeenCalledWith('shell_exec');
+
+    await manager.checkPermission(tool, { command: 'pwd' });
+    expect(handler).toHaveBeenCalledTimes(1); // cached
+  });
+
+  it('should treat boolean true as "session"', async () => {
+    const handler = vi.fn().mockResolvedValue(true);
+    const manager = new PermissionManager(handler);
+    const tool = createMockTool('shell_exec', true);
+
+    await manager.checkPermission(tool);
+    await manager.checkPermission(tool);
+
+    expect(handler).toHaveBeenCalledTimes(1); // cached like session
+  });
+
+  // --- allowTool / revokeTool ---
+
+  it('should skip handler for pre-allowed tools', async () => {
+    const handler = vi.fn().mockResolvedValue('deny');
+    const manager = new PermissionManager(handler);
+    manager.allowTool('shell_exec');
+    const tool = createMockTool('shell_exec', true);
+    expect(await manager.checkPermission(tool)).toBe(true);
+    expect(handler).not.toHaveBeenCalled();
+  });
+
+  it('should support allowTool with "always" level', () => {
+    const manager = new PermissionManager();
+    manager.allowTool('shell_exec', 'always');
+    expect(manager.isAllowed('shell_exec')).toBe(true);
+  });
+
+  it('should revoke tool permission from both levels', () => {
+    const manager = new PermissionManager();
+    manager.allowTool('a', 'session');
+    manager.allowTool('b', 'always');
+    expect(manager.isAllowed('a')).toBe(true);
+    expect(manager.isAllowed('b')).toBe(true);
+    manager.revokeTool('a');
+    manager.revokeTool('b');
+    expect(manager.isAllowed('a')).toBe(false);
+    expect(manager.isAllowed('b')).toBe(false);
+  });
+
+  it('should clear session only', () => {
+    const manager = new PermissionManager();
+    manager.allowTool('a', 'session');
+    manager.allowTool('b', 'always');
+    manager.clearSession();
+    expect(manager.isAllowed('a')).toBe(false);
+    expect(manager.isAllowed('b')).toBe(true); // always survives
+  });
+
+  it('should clear all', () => {
+    const manager = new PermissionManager();
+    manager.allowTool('a', 'session');
+    manager.allowTool('b', 'always');
+    manager.clearAll();
+    expect(manager.isAllowed('a')).toBe(false);
+    expect(manager.isAllowed('b')).toBe(false);
+  });
+});

package/tests/session-manager.test.ts

@@ -0,0 +1,106 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { SessionManager } from '../src/session-manager.js';
+import { MessageManager } from '../src/message-manager.js';
+
+describe('SessionManager', () => {
+  let sessionsDir: string;
+  let sm: SessionManager;
+
+  beforeEach(async () => {
+    sessionsDir = await mkdtemp(join(tmpdir(), 'session-test-'));
+    sm = new SessionManager(sessionsDir);
+  });
+
+  afterEach(async () => {
+    await rm(sessionsDir, { recursive: true, force: true });
+  });
+
+  it('should save and load a session', async () => {
+    const manager = new MessageManager();
+    manager.addSystemMessage('You are helpful.');
+    manager.addUserMessage('Hello');
+    manager.addAssistantMessage('Hi!');
+
+    await sm.save('test-1', manager);
+
+    const restored = new MessageManager();
+    const meta = await sm.load('test-1', restored);
+
+    expect(restored.messageCount).toBe(3);
+    const msgs = restored.getMessages();
+    expect(msgs[0]?.role).toBe('system');
+    expect(msgs[1]?.content).toBe('Hello');
+    expect(msgs[2]?.content).toBe('Hi!');
+    expect(meta.sessionId).toBe('test-1');
+    expect(meta.createdAt).toBeTruthy();
+  });
+
+  it('should preserve createdAt on re-save', async () => {
+    const manager = new MessageManager();
+    manager.addUserMessage('first');
+
+    await sm.save('test-2', manager);
+    const meta1 = await sm.load('test-2', new MessageManager());
+
+    // Wait a tiny bit, then save again
+    manager.addUserMessage('second');
+    await sm.save('test-2', manager);
+    const meta2 = await sm.load('test-2', new MessageManager());
+
+    expect(meta2.createdAt).toBe(meta1.createdAt);
+    expect(meta2.updatedAt >= meta1.updatedAt).toBe(true);
+  });
+
+  it('should check existence', async () => {
+    expect(await sm.exists('nope')).toBe(false);
+
+    const manager = new MessageManager();
+    manager.addUserMessage('hi');
+    await sm.save('exists-1', manager);
+
+    expect(await sm.exists('exists-1')).toBe(true);
+  });
+
+  it('should list sessions sorted by updatedAt', async () => {
+    const m1 = new MessageManager();
+    m1.addUserMessage('session A');
+    await sm.save('a', m1);
+
+    const m2 = new MessageManager();
+    m2.addUserMessage('session B');
+    await sm.save('b', m2);
+
+    const list = await sm.list();
+    expect(list).toHaveLength(2);
+    // Most recent first
+    expect(list[0]?.sessionId).toBe('b');
+    expect(list[1]?.sessionId).toBe('a');
+  });
+
+  it('should return empty list for non-existent directory', async () => {
+    const badSm = new SessionManager('/tmp/nonexistent-session-dir-xyz');
+    const list = await badSm.list();
+    expect(list).toEqual([]);
+  });
+
+  it('should throw on load for non-existent session', async () => {
+    const manager = new MessageManager();
+    await expect(sm.load('missing', manager)).rejects.toThrow();
+  });
+
+  it('should sanitize sessionId to prevent path traversal', async () => {
+    const manager = new MessageManager();
+    manager.addUserMessage('sneaky');
+    // Malicious session ID with path traversal
+    await sm.save('../../../etc/passwd', manager);
+
+    // Should be saved safely inside sessionsDir
+    expect(await sm.exists('../../../etc/passwd')).toBe(true);
+    const list = await sm.list();
+    expect(list).toHaveLength(1);
+    expect(list[0]?.sessionId).toBe('../../../etc/passwd');
+  });
+});

package/tests/skill-tool.test.ts

@@ -0,0 +1,119 @@
+import { describe, it, expect } from 'vitest';
+import { SkillTool, type SkillEntry, type SkillProvider } from '../src/skill-tool.js';
+import type { AgentConfig } from '@charming_groot/core';
+import { RunContext } from '@charming_groot/core';
+
+const TEST_CONFIG: AgentConfig = {
+  provider: { providerId: 'test', model: 'test', auth: { type: 'api-key' as const, apiKey: 'test' }, maxTokens: 4096, temperature: 0.7 },
+  maxIterations: 10,
+  workingDirectory: '/tmp',
+};
+
+function createRegistry(skills: SkillEntry[]): SkillProvider {
+  return {
+    get: (name: string) => skills.find((s) => s.name === name),
+    getAll: () => skills,
+  };
+}
+
+const SAMPLE_SKILLS: SkillEntry[] = [
+  {
+    name: 'code-review',
+    description: 'Review code for quality and bugs',
+    tools: ['file_read', 'content_search'],
+    prompt: 'You are a code reviewer. Analyze code for bugs, style issues, and improvements.',
+    rules: ['no-console-log'],
+  },
+  {
+    name: 'deploy',
+    description: 'Deploy application to production',
+    tools: ['shell_exec', 'file_read'],
+    prompt: 'You are a deployment specialist. Follow the deployment checklist carefully.',
+    rules: ['require-approval', 'dry-run-first'],
+  },
+];
+
+describe('SkillTool', () => {
+  const context = new RunContext(TEST_CONFIG);
+
+  it('should describe itself correctly', () => {
+    const tool = new SkillTool(createRegistry([]));
+    const desc = tool.describe();
+    expect(desc.name).toBe('skill');
+    expect(desc.parameters.length).toBeGreaterThanOrEqual(2);
+  });
+
+  it('should list available skills', async () => {
+    const tool = new SkillTool(createRegistry(SAMPLE_SKILLS));
+    const result = await tool.execute({ action: 'list' }, context);
+
+    expect(result.success).toBe(true);
+    expect(result.output).toContain('code-review');
+    expect(result.output).toContain('deploy');
+    expect(result.output).toContain('file_read');
+  });
+
+  it('should return empty message when no skills', async () => {
+    const tool = new SkillTool(createRegistry([]));
+    const result = await tool.execute({ action: 'list' }, context);
+
+    expect(result.success).toBe(true);
+    expect(result.output).toContain('No skills available');
+  });
+
+  it('should invoke a skill by name', async () => {
+    const tool = new SkillTool(createRegistry(SAMPLE_SKILLS));
+    const result = await tool.execute({ action: 'invoke', name: 'code-review' }, context);
+
+    expect(result.success).toBe(true);
+    expect(result.output).toContain('code-review');
+    expect(result.output).toContain('code reviewer');
+    expect(result.output).toContain('file_read, content_search');
+    expect(result.output).toContain('no-console-log');
+    expect(result.metadata?.['skillName']).toBe('code-review');
+  });
+
+  it('should include user input in invocation', async () => {
+    const tool = new SkillTool(createRegistry(SAMPLE_SKILLS));
+    const result = await tool.execute(
+      { action: 'invoke', name: 'deploy', input: 'Deploy v2.1.0 to staging' },
+      context,
+    );
+
+    expect(result.success).toBe(true);
+    expect(result.output).toContain('Deploy v2.1.0 to staging');
+    expect(result.output).toContain('deployment specialist');
+  });
+
+  it('should return error for unknown skill', async () => {
+    const tool = new SkillTool(createRegistry(SAMPLE_SKILLS));
+    const result = await tool.execute({ action: 'invoke', name: 'nonexistent' }, context);
+
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('not found');
+  });
+
+  it('should return error for missing name on invoke', async () => {
+    const tool = new SkillTool(createRegistry(SAMPLE_SKILLS));
+    const result = await tool.execute({ action: 'invoke' }, context);
+
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('Missing "name"');
+  });
+
+  it('should return error for unknown action', async () => {
+    const tool = new SkillTool(createRegistry(SAMPLE_SKILLS));
+    const result = await tool.execute({ action: 'delete' }, context);
+
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('Unknown action');
+  });
+
+  it('should return metadata with tools and rules on invoke', async () => {
+    const tool = new SkillTool(createRegistry(SAMPLE_SKILLS));
+    const result = await tool.execute({ action: 'invoke', name: 'deploy' }, context);
+
+    expect(result.metadata?.['tools']).toEqual(['shell_exec', 'file_read']);
+    expect(result.metadata?.['rules']).toEqual(['require-approval', 'dry-run-first']);
+  });
+});