mirror of
https://github.com/QwenLM/qwen-code.git
synced 2025-12-19 09:33:53 +00:00
1138 lines
36 KiB
TypeScript
1138 lines
36 KiB
TypeScript
/**
|
|
* @license
|
|
* Copyright 2025 Qwen
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*/
|
|
|
|
import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
|
|
import * as fs from 'fs/promises';
|
|
import * as path from 'path';
|
|
import * as os from 'os';
|
|
import { SubagentManager } from './subagent-manager.js';
|
|
import { type SubagentConfig, SubagentError } from './types.js';
|
|
import type { ToolRegistry } from '../tools/tool-registry.js';
|
|
import type { Config } from '../config/config.js';
|
|
import { makeFakeConfig } from '../test-utils/config.js';
|
|
|
|
// Mock file system operations
|
|
vi.mock('fs/promises');
|
|
vi.mock('os');
|
|
|
|
// Mock yaml parser - use vi.hoisted for proper hoisting
|
|
const mockParseYaml = vi.hoisted(() => vi.fn());
|
|
const mockStringifyYaml = vi.hoisted(() => vi.fn());
|
|
|
|
vi.mock('../utils/yaml-parser.js', () => ({
|
|
parse: mockParseYaml,
|
|
stringify: mockStringifyYaml,
|
|
}));
|
|
|
|
// Mock dependencies - create mock functions at the top level
|
|
const mockValidateConfig = vi.hoisted(() => vi.fn());
|
|
const mockValidateOrThrow = vi.hoisted(() => vi.fn());
|
|
|
|
vi.mock('./validation.js', () => ({
|
|
SubagentValidator: class MockSubagentValidator {
|
|
validateConfig = mockValidateConfig;
|
|
validateOrThrow = mockValidateOrThrow;
|
|
},
|
|
}));
|
|
|
|
vi.mock('./subagent.js');
|
|
|
|
describe('SubagentManager', () => {
|
|
let manager: SubagentManager;
|
|
let mockToolRegistry: ToolRegistry;
|
|
let mockConfig: Config;
|
|
|
|
beforeEach(() => {
|
|
mockToolRegistry = {
|
|
getAllTools: vi.fn().mockReturnValue([
|
|
{ name: 'read_file', displayName: 'Read File' },
|
|
{ name: 'write_file', displayName: 'Write File' },
|
|
{ name: 'grep', displayName: 'Search Files' },
|
|
]),
|
|
} as unknown as ToolRegistry;
|
|
|
|
// Create mock Config object using test utility
|
|
mockConfig = makeFakeConfig({});
|
|
|
|
// Mock the tool registry and project root methods
|
|
vi.spyOn(mockConfig, 'getToolRegistry').mockReturnValue(mockToolRegistry);
|
|
vi.spyOn(mockConfig, 'getProjectRoot').mockReturnValue('/test/project');
|
|
|
|
// Mock os.homedir
|
|
vi.mocked(os.homedir).mockReturnValue('/home/user');
|
|
|
|
// Reset and setup mocks
|
|
vi.clearAllMocks();
|
|
mockValidateConfig.mockReturnValue({
|
|
isValid: true,
|
|
errors: [],
|
|
warnings: [],
|
|
});
|
|
mockValidateOrThrow.mockImplementation(() => {});
|
|
|
|
// Setup yaml parser mocks with sophisticated behavior
|
|
mockParseYaml.mockImplementation((yamlString: string) => {
|
|
// Handle different test cases based on YAML content
|
|
if (yamlString.includes('tools:')) {
|
|
return {
|
|
name: 'test-agent',
|
|
description: 'A test subagent',
|
|
tools: ['read_file', 'write_file'],
|
|
};
|
|
}
|
|
if (yamlString.includes('modelConfig:')) {
|
|
return {
|
|
name: 'test-agent',
|
|
description: 'A test subagent',
|
|
modelConfig: { model: 'custom-model', temp: 0.5 },
|
|
};
|
|
}
|
|
if (yamlString.includes('runConfig:')) {
|
|
return {
|
|
name: 'test-agent',
|
|
description: 'A test subagent',
|
|
runConfig: { max_time_minutes: 5, max_turns: 10 },
|
|
};
|
|
}
|
|
if (yamlString.includes('name: agent1')) {
|
|
return { name: 'agent1', description: 'First agent' };
|
|
}
|
|
if (yamlString.includes('name: agent2')) {
|
|
return { name: 'agent2', description: 'Second agent' };
|
|
}
|
|
if (yamlString.includes('name: agent3')) {
|
|
return { name: 'agent3', description: 'Third agent' };
|
|
}
|
|
if (yamlString.includes('name: 11')) {
|
|
return { name: 11, description: 333 }; // Numeric values test case
|
|
}
|
|
if (yamlString.includes('name: true')) {
|
|
return { name: true, description: false }; // Boolean values test case
|
|
}
|
|
if (!yamlString.includes('name:')) {
|
|
return { description: 'A test subagent' }; // Missing name case
|
|
}
|
|
if (!yamlString.includes('description:')) {
|
|
return { name: 'test-agent' }; // Missing description case
|
|
}
|
|
// Default case
|
|
return {
|
|
name: 'test-agent',
|
|
description: 'A test subagent',
|
|
};
|
|
});
|
|
|
|
mockStringifyYaml.mockImplementation((obj: Record<string, unknown>) => {
|
|
let yaml = '';
|
|
for (const [key, value] of Object.entries(obj)) {
|
|
if (key === 'tools' && Array.isArray(value)) {
|
|
yaml += `tools:\n${value.map((tool) => ` - ${tool}`).join('\n')}\n`;
|
|
} else if (
|
|
key === 'modelConfig' &&
|
|
typeof value === 'object' &&
|
|
value
|
|
) {
|
|
yaml += `modelConfig:\n`;
|
|
for (const [k, v] of Object.entries(
|
|
value as Record<string, unknown>,
|
|
)) {
|
|
yaml += ` ${k}: ${v}\n`;
|
|
}
|
|
} else if (key === 'runConfig' && typeof value === 'object' && value) {
|
|
yaml += `runConfig:\n`;
|
|
for (const [k, v] of Object.entries(
|
|
value as Record<string, unknown>,
|
|
)) {
|
|
yaml += ` ${k}: ${v}\n`;
|
|
}
|
|
} else {
|
|
yaml += `${key}: ${value}\n`;
|
|
}
|
|
}
|
|
return yaml.trim();
|
|
});
|
|
|
|
manager = new SubagentManager(mockConfig);
|
|
});
|
|
|
|
afterEach(() => {
|
|
vi.restoreAllMocks();
|
|
});
|
|
|
|
const validConfig: SubagentConfig = {
|
|
name: 'test-agent',
|
|
description: 'A test subagent',
|
|
systemPrompt: 'You are a helpful assistant.',
|
|
level: 'project',
|
|
filePath: '/test/project/.qwen/agents/test-agent.md',
|
|
};
|
|
|
|
const validMarkdown = `---
|
|
name: test-agent
|
|
description: A test subagent
|
|
---
|
|
|
|
You are a helpful assistant.
|
|
`;
|
|
|
|
describe('parseSubagentContent', () => {
|
|
it('should parse valid markdown content', () => {
|
|
const config = manager.parseSubagentContent(
|
|
validMarkdown,
|
|
validConfig.filePath!,
|
|
'project',
|
|
);
|
|
|
|
expect(config.name).toBe('test-agent');
|
|
expect(config.description).toBe('A test subagent');
|
|
expect(config.systemPrompt).toBe('You are a helpful assistant.');
|
|
expect(config.level).toBe('project');
|
|
expect(config.filePath).toBe(validConfig.filePath);
|
|
});
|
|
|
|
it('should parse content with tools', () => {
|
|
const markdownWithTools = `---
|
|
name: test-agent
|
|
description: A test subagent
|
|
tools:
|
|
- read_file
|
|
- write_file
|
|
---
|
|
|
|
You are a helpful assistant.
|
|
`;
|
|
|
|
const config = manager.parseSubagentContent(
|
|
markdownWithTools,
|
|
validConfig.filePath!,
|
|
'project',
|
|
);
|
|
|
|
expect(config.tools).toEqual(['read_file', 'write_file']);
|
|
});
|
|
|
|
it('should parse content with model config', () => {
|
|
const markdownWithModel = `---
|
|
name: test-agent
|
|
description: A test subagent
|
|
modelConfig:
|
|
model: custom-model
|
|
temp: 0.5
|
|
---
|
|
|
|
You are a helpful assistant.
|
|
`;
|
|
|
|
const config = manager.parseSubagentContent(
|
|
markdownWithModel,
|
|
validConfig.filePath!,
|
|
'project',
|
|
);
|
|
|
|
expect(config.modelConfig).toEqual({ model: 'custom-model', temp: 0.5 });
|
|
});
|
|
|
|
it('should parse content with run config', () => {
|
|
const markdownWithRun = `---
|
|
name: test-agent
|
|
description: A test subagent
|
|
runConfig:
|
|
max_time_minutes: 5
|
|
max_turns: 10
|
|
---
|
|
|
|
You are a helpful assistant.
|
|
`;
|
|
|
|
const config = manager.parseSubagentContent(
|
|
markdownWithRun,
|
|
validConfig.filePath!,
|
|
'project',
|
|
);
|
|
|
|
expect(config.runConfig).toEqual({ max_time_minutes: 5, max_turns: 10 });
|
|
});
|
|
|
|
it('should handle numeric name and description values', () => {
|
|
const markdownWithNumeric = `---
|
|
name: 11
|
|
description: 333
|
|
---
|
|
|
|
You are a helpful assistant.
|
|
`;
|
|
|
|
const config = manager.parseSubagentContent(
|
|
markdownWithNumeric,
|
|
validConfig.filePath!,
|
|
'project',
|
|
);
|
|
|
|
expect(config.name).toBe('11');
|
|
expect(config.description).toBe('333');
|
|
expect(typeof config.name).toBe('string');
|
|
expect(typeof config.description).toBe('string');
|
|
});
|
|
|
|
it('should handle boolean name and description values', () => {
|
|
const markdownWithBoolean = `---
|
|
name: true
|
|
description: false
|
|
---
|
|
|
|
You are a helpful assistant.
|
|
`;
|
|
|
|
const config = manager.parseSubagentContent(
|
|
markdownWithBoolean,
|
|
validConfig.filePath!,
|
|
'project',
|
|
);
|
|
|
|
expect(config.name).toBe('true');
|
|
expect(config.description).toBe('false');
|
|
expect(typeof config.name).toBe('string');
|
|
expect(typeof config.description).toBe('string');
|
|
});
|
|
|
|
it('should determine level from file path', () => {
|
|
const projectPath = '/test/project/.qwen/agents/test-agent.md';
|
|
const userPath = '/home/user/.qwen/agents/test-agent.md';
|
|
|
|
const projectConfig = manager.parseSubagentContent(
|
|
validMarkdown,
|
|
projectPath,
|
|
'project',
|
|
);
|
|
const userConfig = manager.parseSubagentContent(
|
|
validMarkdown,
|
|
userPath,
|
|
'user',
|
|
);
|
|
|
|
expect(projectConfig.level).toBe('project');
|
|
expect(userConfig.level).toBe('user');
|
|
});
|
|
|
|
it('should throw error for invalid frontmatter format', () => {
|
|
const invalidMarkdown = `No frontmatter here
|
|
Just content`;
|
|
|
|
expect(() =>
|
|
manager.parseSubagentContent(
|
|
invalidMarkdown,
|
|
validConfig.filePath!,
|
|
'project',
|
|
),
|
|
).toThrow(SubagentError);
|
|
});
|
|
|
|
it('should throw error for missing name', () => {
|
|
const markdownWithoutName = `---
|
|
description: A test subagent
|
|
---
|
|
|
|
You are a helpful assistant.
|
|
`;
|
|
|
|
expect(() =>
|
|
manager.parseSubagentContent(
|
|
markdownWithoutName,
|
|
validConfig.filePath!,
|
|
'project',
|
|
),
|
|
).toThrow(SubagentError);
|
|
});
|
|
|
|
it('should throw error for missing description', () => {
|
|
const markdownWithoutDescription = `---
|
|
name: test-agent
|
|
---
|
|
|
|
You are a helpful assistant.
|
|
`;
|
|
|
|
expect(() =>
|
|
manager.parseSubagentContent(
|
|
markdownWithoutDescription,
|
|
validConfig.filePath!,
|
|
'project',
|
|
),
|
|
).toThrow(SubagentError);
|
|
});
|
|
|
|
it('should not warn when filename matches subagent name', () => {
|
|
const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
|
|
const matchingPath = '/test/project/.qwen/agents/test-agent.md';
|
|
|
|
const config = manager.parseSubagentContent(
|
|
validMarkdown,
|
|
matchingPath,
|
|
'project',
|
|
);
|
|
|
|
expect(config.name).toBe('test-agent');
|
|
expect(consoleSpy).not.toHaveBeenCalled();
|
|
|
|
consoleSpy.mockRestore();
|
|
});
|
|
});
|
|
|
|
describe('serializeSubagent', () => {
|
|
it('should serialize basic configuration', () => {
|
|
const serialized = manager.serializeSubagent(validConfig);
|
|
|
|
expect(serialized).toContain('name: test-agent');
|
|
expect(serialized).toContain('description: A test subagent');
|
|
expect(serialized).toContain('You are a helpful assistant.');
|
|
expect(serialized).toMatch(/^---\n[\s\S]*\n---\n\n[\s\S]*\n$/);
|
|
});
|
|
|
|
it('should serialize configuration with tools', () => {
|
|
const configWithTools: SubagentConfig = {
|
|
...validConfig,
|
|
tools: ['read_file', 'write_file'],
|
|
};
|
|
|
|
const serialized = manager.serializeSubagent(configWithTools);
|
|
|
|
expect(serialized).toContain('tools:');
|
|
expect(serialized).toContain('- read_file');
|
|
expect(serialized).toContain('- write_file');
|
|
});
|
|
|
|
it('should serialize configuration with model config', () => {
|
|
const configWithModel: SubagentConfig = {
|
|
...validConfig,
|
|
modelConfig: { model: 'custom-model', temp: 0.5 },
|
|
};
|
|
|
|
const serialized = manager.serializeSubagent(configWithModel);
|
|
|
|
expect(serialized).toContain('modelConfig:');
|
|
expect(serialized).toContain('model: custom-model');
|
|
expect(serialized).toContain('temp: 0.5');
|
|
});
|
|
|
|
it('should not include empty optional fields', () => {
|
|
const serialized = manager.serializeSubagent(validConfig);
|
|
|
|
expect(serialized).not.toContain('tools:');
|
|
expect(serialized).not.toContain('modelConfig:');
|
|
expect(serialized).not.toContain('runConfig:');
|
|
});
|
|
});
|
|
|
|
describe('createSubagent', () => {
|
|
beforeEach(() => {
|
|
// Mock successful file operations
|
|
vi.mocked(fs.access).mockRejectedValue(new Error('File not found'));
|
|
vi.mocked(fs.mkdir).mockResolvedValue(undefined);
|
|
vi.mocked(fs.writeFile).mockResolvedValue(undefined);
|
|
});
|
|
|
|
it('should create subagent successfully', async () => {
|
|
await manager.createSubagent(validConfig, { level: 'project' });
|
|
|
|
expect(fs.mkdir).toHaveBeenCalledWith(
|
|
path.normalize(path.dirname(validConfig.filePath!)),
|
|
{ recursive: true },
|
|
);
|
|
expect(fs.writeFile).toHaveBeenCalledWith(
|
|
expect.stringContaining('test-agent.md'),
|
|
expect.stringContaining('name: test-agent'),
|
|
'utf8',
|
|
);
|
|
});
|
|
|
|
it('should throw error if file already exists and overwrite is false', async () => {
|
|
vi.mocked(fs.access).mockResolvedValue(undefined); // File exists
|
|
|
|
await expect(
|
|
manager.createSubagent(validConfig, { level: 'project' }),
|
|
).rejects.toThrow(SubagentError);
|
|
|
|
await expect(
|
|
manager.createSubagent(validConfig, { level: 'project' }),
|
|
).rejects.toThrow(/already exists/);
|
|
});
|
|
|
|
it('should overwrite file when overwrite is true', async () => {
|
|
vi.mocked(fs.access).mockResolvedValue(undefined); // File exists
|
|
|
|
await manager.createSubagent(validConfig, {
|
|
level: 'project',
|
|
overwrite: true,
|
|
});
|
|
|
|
expect(fs.writeFile).toHaveBeenCalled();
|
|
});
|
|
|
|
it('should use custom path when provided', async () => {
|
|
const customPath = '/custom/path/agent.md';
|
|
|
|
await manager.createSubagent(validConfig, {
|
|
level: 'project',
|
|
customPath,
|
|
});
|
|
|
|
expect(fs.writeFile).toHaveBeenCalledWith(
|
|
customPath,
|
|
expect.any(String),
|
|
'utf8',
|
|
);
|
|
});
|
|
|
|
it('should throw error on file write failure', async () => {
|
|
vi.mocked(fs.writeFile).mockRejectedValue(new Error('Write failed'));
|
|
|
|
await expect(
|
|
manager.createSubagent(validConfig, { level: 'project' }),
|
|
).rejects.toThrow(SubagentError);
|
|
|
|
await expect(
|
|
manager.createSubagent(validConfig, { level: 'project' }),
|
|
).rejects.toThrow(/Failed to write subagent file/);
|
|
});
|
|
});
|
|
|
|
describe('loadSubagent', () => {
|
|
it('should load subagent from project level first', async () => {
|
|
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
vi.mocked(fs.readdir).mockResolvedValue(['test-agent.md'] as any);
|
|
vi.mocked(fs.readFile).mockResolvedValue(validMarkdown);
|
|
|
|
const config = await manager.loadSubagent('test-agent');
|
|
|
|
expect(config).toBeDefined();
|
|
expect(config!.name).toBe('test-agent');
|
|
expect(fs.readdir).toHaveBeenCalledWith(
|
|
path.normalize('/test/project/.qwen/agents'),
|
|
);
|
|
expect(fs.readFile).toHaveBeenCalledWith(
|
|
path.normalize('/test/project/.qwen/agents/test-agent.md'),
|
|
'utf8',
|
|
);
|
|
});
|
|
|
|
it('should fall back to user level if project level fails', async () => {
|
|
vi.mocked(fs.readdir)
|
|
.mockRejectedValueOnce(new Error('Project dir not found')) // project level fails
|
|
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
.mockResolvedValueOnce(['test-agent.md'] as any); // user level succeeds
|
|
vi.mocked(fs.readFile).mockResolvedValue(validMarkdown);
|
|
|
|
const config = await manager.loadSubagent('test-agent');
|
|
|
|
expect(config).toBeDefined();
|
|
expect(config!.name).toBe('test-agent');
|
|
expect(fs.readdir).toHaveBeenCalledWith(
|
|
path.normalize('/home/user/.qwen/agents'),
|
|
);
|
|
expect(fs.readFile).toHaveBeenCalledWith(
|
|
path.normalize('/home/user/.qwen/agents/test-agent.md'),
|
|
'utf8',
|
|
);
|
|
});
|
|
|
|
it('should return null if not found at either level', async () => {
|
|
vi.mocked(fs.readdir).mockRejectedValue(new Error('Directory not found'));
|
|
|
|
const config = await manager.loadSubagent('nonexistent');
|
|
|
|
expect(config).toBeNull();
|
|
});
|
|
|
|
it('should load subagent even when filename does not match name', async () => {
|
|
// Mock readdir to return files with different names
|
|
vi.mocked(fs.readdir).mockResolvedValue([
|
|
'wrong-filename.md',
|
|
'another-file.md',
|
|
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
] as any);
|
|
|
|
// Mock readFile to return content with different name
|
|
const mismatchedMarkdown = `---
|
|
name: correct-agent-name
|
|
description: A test subagent with mismatched filename
|
|
---
|
|
|
|
You are a helpful assistant.`;
|
|
|
|
const anotherFileMarkdown = `---
|
|
name: other-agent
|
|
description: Some other agent
|
|
---
|
|
|
|
You are another assistant.`;
|
|
|
|
vi.mocked(fs.readFile)
|
|
.mockResolvedValueOnce(mismatchedMarkdown) // first file (wrong-filename.md) - matches!
|
|
.mockResolvedValueOnce(anotherFileMarkdown); // second file (another-file.md) - doesn't match
|
|
|
|
// Mock parseYaml for different scenarios
|
|
mockParseYaml
|
|
.mockReturnValueOnce({
|
|
name: 'correct-agent-name',
|
|
description: 'A test subagent with mismatched filename',
|
|
})
|
|
.mockReturnValueOnce({
|
|
name: 'other-agent',
|
|
description: 'Some other agent',
|
|
});
|
|
|
|
const config = await manager.loadSubagent('correct-agent-name');
|
|
|
|
expect(config).toBeDefined();
|
|
expect(config!.name).toBe('correct-agent-name');
|
|
expect(config!.filePath).toBe(
|
|
path.normalize('/test/project/.qwen/agents/wrong-filename.md'),
|
|
);
|
|
|
|
// Verify it scanned the directory instead of using direct path
|
|
expect(fs.readdir).toHaveBeenCalledWith(
|
|
path.normalize('/test/project/.qwen/agents'),
|
|
);
|
|
});
|
|
|
|
it('should search user level when filename mismatch at project level', async () => {
|
|
// Mock project level to have no matching files
|
|
vi.mocked(fs.readdir)
|
|
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
.mockResolvedValueOnce(['other-file.md'] as any) // project level
|
|
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
.mockResolvedValueOnce(['user-agent.md'] as any); // user level
|
|
|
|
const projectMarkdown = `---
|
|
name: wrong-agent
|
|
description: Wrong agent
|
|
---
|
|
|
|
You are a wrong assistant.`;
|
|
|
|
const userMarkdown = `---
|
|
name: target-agent
|
|
description: A test subagent at user level
|
|
---
|
|
|
|
You are a helpful assistant.`;
|
|
|
|
vi.mocked(fs.readFile)
|
|
.mockResolvedValueOnce(projectMarkdown) // project level file (other-file.md)
|
|
.mockResolvedValueOnce(userMarkdown); // user level file (user-agent.md)
|
|
|
|
// Mock parseYaml for different scenarios
|
|
mockParseYaml
|
|
.mockReturnValueOnce({
|
|
name: 'wrong-agent',
|
|
description: 'Wrong agent',
|
|
})
|
|
.mockReturnValueOnce({
|
|
name: 'target-agent',
|
|
description: 'A test subagent at user level',
|
|
});
|
|
|
|
const config = await manager.loadSubagent('target-agent');
|
|
|
|
expect(config).toBeDefined();
|
|
expect(config!.name).toBe('target-agent');
|
|
expect(config!.filePath).toBe(
|
|
path.normalize('/home/user/.qwen/agents/user-agent.md'),
|
|
);
|
|
expect(config!.level).toBe('user');
|
|
});
|
|
|
|
it('should handle specific level search with filename mismatch', async () => {
|
|
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
vi.mocked(fs.readdir).mockResolvedValue(['misnamed-file.md'] as any);
|
|
|
|
const levelMarkdown = `---
|
|
name: specific-agent
|
|
description: A test subagent for specific level
|
|
---
|
|
|
|
You are a helpful assistant.`;
|
|
|
|
vi.mocked(fs.readFile).mockResolvedValue(levelMarkdown);
|
|
|
|
mockParseYaml.mockReturnValue({
|
|
name: 'specific-agent',
|
|
description: 'A test subagent for specific level',
|
|
});
|
|
|
|
const config = await manager.loadSubagent('specific-agent', 'project');
|
|
|
|
expect(config).toBeDefined();
|
|
expect(config!.name).toBe('specific-agent');
|
|
expect(config!.filePath).toBe(
|
|
path.normalize('/test/project/.qwen/agents/misnamed-file.md'),
|
|
);
|
|
});
|
|
});
|
|
|
|
describe('updateSubagent', () => {
|
|
beforeEach(() => {
|
|
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
vi.mocked(fs.readdir).mockResolvedValue(['test-agent.md'] as any);
|
|
vi.mocked(fs.readFile).mockResolvedValue(validMarkdown);
|
|
vi.mocked(fs.writeFile).mockResolvedValue(undefined);
|
|
});
|
|
|
|
it('should update existing subagent', async () => {
|
|
const updates = { description: 'Updated description' };
|
|
|
|
await manager.updateSubagent('test-agent', updates);
|
|
|
|
expect(fs.writeFile).toHaveBeenCalledWith(
|
|
expect.stringContaining('test-agent.md'),
|
|
expect.stringContaining('Updated description'),
|
|
'utf8',
|
|
);
|
|
});
|
|
|
|
it('should throw error if subagent not found', async () => {
|
|
vi.mocked(fs.readdir).mockRejectedValue(new Error('Directory not found'));
|
|
|
|
await expect(manager.updateSubagent('nonexistent', {})).rejects.toThrow(
|
|
SubagentError,
|
|
);
|
|
|
|
await expect(manager.updateSubagent('nonexistent', {})).rejects.toThrow(
|
|
/not found/,
|
|
);
|
|
});
|
|
|
|
it('should throw error on write failure', async () => {
|
|
vi.mocked(fs.writeFile).mockRejectedValue(new Error('Write failed'));
|
|
|
|
await expect(manager.updateSubagent('test-agent', {})).rejects.toThrow(
|
|
SubagentError,
|
|
);
|
|
|
|
await expect(manager.updateSubagent('test-agent', {})).rejects.toThrow(
|
|
/Failed to update subagent file/,
|
|
);
|
|
});
|
|
});
|
|
|
|
describe('deleteSubagent', () => {
|
|
it('should delete subagent from specified level', async () => {
|
|
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
vi.mocked(fs.readdir).mockResolvedValue(['test-agent.md'] as any);
|
|
vi.mocked(fs.readFile).mockResolvedValue(validMarkdown);
|
|
vi.mocked(fs.unlink).mockResolvedValue(undefined);
|
|
|
|
await manager.deleteSubagent('test-agent', 'project');
|
|
|
|
expect(fs.unlink).toHaveBeenCalledWith(
|
|
path.normalize('/test/project/.qwen/agents/test-agent.md'),
|
|
);
|
|
});
|
|
|
|
it('should delete from both levels if no level specified', async () => {
|
|
vi.mocked(fs.readdir)
|
|
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
.mockResolvedValueOnce(['test-agent.md'] as any) // project level
|
|
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
.mockResolvedValueOnce(['test-agent.md'] as any); // user level
|
|
vi.mocked(fs.readFile).mockResolvedValue(validMarkdown);
|
|
vi.mocked(fs.unlink).mockResolvedValue(undefined);
|
|
|
|
await manager.deleteSubagent('test-agent');
|
|
|
|
expect(fs.unlink).toHaveBeenCalledTimes(2);
|
|
expect(fs.unlink).toHaveBeenCalledWith(
|
|
path.normalize('/test/project/.qwen/agents/test-agent.md'),
|
|
);
|
|
expect(fs.unlink).toHaveBeenCalledWith(
|
|
path.normalize('/home/user/.qwen/agents/test-agent.md'),
|
|
);
|
|
});
|
|
|
|
it('should throw error if subagent not found', async () => {
|
|
vi.mocked(fs.readdir).mockRejectedValue(new Error('Directory not found'));
|
|
|
|
await expect(manager.deleteSubagent('nonexistent')).rejects.toThrow(
|
|
SubagentError,
|
|
);
|
|
|
|
await expect(manager.deleteSubagent('nonexistent')).rejects.toThrow(
|
|
/not found/,
|
|
);
|
|
});
|
|
|
|
it('should succeed if deleted from at least one level', async () => {
|
|
vi.mocked(fs.readdir)
|
|
.mockRejectedValueOnce(new Error('Project dir not found')) // project level fails
|
|
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
.mockResolvedValueOnce(['test-agent.md'] as any); // user level succeeds
|
|
vi.mocked(fs.readFile).mockResolvedValue(validMarkdown);
|
|
vi.mocked(fs.unlink).mockResolvedValue(undefined);
|
|
|
|
await expect(manager.deleteSubagent('test-agent')).resolves.not.toThrow();
|
|
});
|
|
|
|
it('should delete subagent with mismatched filename', async () => {
|
|
// Mock directory listing to return files with different names
|
|
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
vi.mocked(fs.readdir).mockResolvedValue(['wrong-name.md'] as any);
|
|
|
|
const mismatchedMarkdown = `---
|
|
name: correct-name
|
|
description: A test subagent with mismatched filename
|
|
---
|
|
|
|
You are a helpful assistant.`;
|
|
|
|
vi.mocked(fs.readFile).mockResolvedValue(mismatchedMarkdown);
|
|
vi.mocked(fs.unlink).mockResolvedValue(undefined);
|
|
|
|
mockParseYaml.mockReturnValue({
|
|
name: 'correct-name',
|
|
description: 'A test subagent with mismatched filename',
|
|
});
|
|
|
|
await manager.deleteSubagent('correct-name', 'project');
|
|
|
|
// Should delete the actual file, not the expected filename
|
|
expect(fs.unlink).toHaveBeenCalledWith(
|
|
path.normalize('/test/project/.qwen/agents/wrong-name.md'),
|
|
);
|
|
});
|
|
|
|
it('should handle deletion when multiple files exist but only one matches', async () => {
|
|
// Mock directory listing with multiple files
|
|
vi.mocked(fs.readdir).mockResolvedValue([
|
|
'file1.md',
|
|
'file2.md',
|
|
'target-file.md',
|
|
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
] as any);
|
|
|
|
const markdowns = [
|
|
`---
|
|
name: other-agent-1
|
|
description: First other agent
|
|
---
|
|
Content 1`,
|
|
`---
|
|
name: other-agent-2
|
|
description: Second other agent
|
|
---
|
|
Content 2`,
|
|
`---
|
|
name: target-agent
|
|
description: The target agent
|
|
---
|
|
Target content`,
|
|
];
|
|
|
|
vi.mocked(fs.readFile)
|
|
.mockResolvedValueOnce(markdowns[0])
|
|
.mockResolvedValueOnce(markdowns[1])
|
|
.mockResolvedValueOnce(markdowns[2]);
|
|
|
|
vi.mocked(fs.unlink).mockResolvedValue(undefined);
|
|
|
|
mockParseYaml
|
|
.mockReturnValueOnce({
|
|
name: 'other-agent-1',
|
|
description: 'First other agent',
|
|
})
|
|
.mockReturnValueOnce({
|
|
name: 'other-agent-2',
|
|
description: 'Second other agent',
|
|
})
|
|
.mockReturnValueOnce({
|
|
name: 'target-agent',
|
|
description: 'The target agent',
|
|
});
|
|
|
|
await manager.deleteSubagent('target-agent', 'project');
|
|
|
|
// Should only delete the matching file
|
|
expect(fs.unlink).toHaveBeenCalledTimes(1);
|
|
expect(fs.unlink).toHaveBeenCalledWith(
|
|
path.normalize('/test/project/.qwen/agents/target-file.md'),
|
|
);
|
|
});
|
|
});
|
|
|
|
describe('listSubagents', () => {
|
|
beforeEach(() => {
|
|
// Mock directory listing
|
|
vi.mocked(fs.readdir)
|
|
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
.mockResolvedValueOnce(['agent1.md', 'agent2.md', 'not-md.txt'] as any)
|
|
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
.mockResolvedValueOnce(['agent3.md', 'agent1.md'] as any); // user level
|
|
|
|
// Mock file reading for valid agents
|
|
vi.mocked(fs.readFile).mockImplementation((filePath) => {
|
|
const pathStr = String(filePath);
|
|
if (pathStr.includes('agent1.md')) {
|
|
return Promise.resolve(`---
|
|
name: agent1
|
|
description: First agent
|
|
---
|
|
System prompt 1`);
|
|
} else if (pathStr.includes('agent2.md')) {
|
|
return Promise.resolve(`---
|
|
name: agent2
|
|
description: Second agent
|
|
---
|
|
System prompt 2`);
|
|
} else if (pathStr.includes('agent3.md')) {
|
|
return Promise.resolve(`---
|
|
name: agent3
|
|
description: Third agent
|
|
---
|
|
System prompt 3`);
|
|
}
|
|
return Promise.reject(new Error('File not found'));
|
|
});
|
|
});
|
|
|
|
it('should list subagents from both levels', async () => {
|
|
const subagents = await manager.listSubagents();
|
|
|
|
expect(subagents).toHaveLength(4); // agent1 (project takes precedence), agent2, agent3, general-purpose (built-in)
|
|
expect(subagents.map((s) => s.name)).toEqual([
|
|
'agent1',
|
|
'agent2',
|
|
'agent3',
|
|
'general-purpose',
|
|
]);
|
|
});
|
|
|
|
it('should prioritize project level over user level', async () => {
|
|
const subagents = await manager.listSubagents();
|
|
const agent1 = subagents.find((s) => s.name === 'agent1');
|
|
|
|
expect(agent1!.level).toBe('project');
|
|
});
|
|
|
|
it('should filter by level', async () => {
|
|
const projectSubagents = await manager.listSubagents({
|
|
level: 'project',
|
|
});
|
|
|
|
expect(projectSubagents).toHaveLength(2); // agent1, agent2
|
|
expect(projectSubagents.every((s) => s.level === 'project')).toBe(true);
|
|
});
|
|
|
|
it('should sort by name', async () => {
|
|
const subagents = await manager.listSubagents({
|
|
sortBy: 'name',
|
|
sortOrder: 'asc',
|
|
});
|
|
|
|
const names = subagents.map((s) => s.name);
|
|
expect(names).toEqual(['agent1', 'agent2', 'agent3', 'general-purpose']);
|
|
});
|
|
|
|
it('should handle empty directories', async () => {
|
|
// Reset all mocks for this specific test
|
|
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
vi.mocked(fs.readdir).mockResolvedValue([] as any);
|
|
vi.mocked(fs.readFile).mockRejectedValue(new Error('No files'));
|
|
|
|
const subagents = await manager.listSubagents();
|
|
|
|
expect(subagents).toHaveLength(1); // Only built-in agents remain
|
|
expect(subagents[0].name).toBe('general-purpose');
|
|
expect(subagents[0].level).toBe('builtin');
|
|
});
|
|
|
|
it('should handle directory read errors', async () => {
|
|
// Reset all mocks for this specific test
|
|
vi.mocked(fs.readdir).mockRejectedValue(new Error('Directory not found'));
|
|
vi.mocked(fs.readFile).mockRejectedValue(new Error('No files'));
|
|
|
|
const subagents = await manager.listSubagents();
|
|
|
|
expect(subagents).toHaveLength(1); // Only built-in agents remain
|
|
expect(subagents[0].name).toBe('general-purpose');
|
|
expect(subagents[0].level).toBe('builtin');
|
|
});
|
|
});
|
|
|
|
describe('findSubagentByName', () => {
|
|
it('should find existing subagent', async () => {
|
|
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
vi.mocked(fs.readdir).mockResolvedValue(['test-agent.md'] as any);
|
|
vi.mocked(fs.readFile).mockResolvedValue(validMarkdown);
|
|
|
|
const metadata = await manager.findSubagentByName('test-agent');
|
|
|
|
expect(metadata).toBeDefined();
|
|
expect(metadata!.name).toBe('test-agent');
|
|
expect(metadata!.description).toBe('A test subagent');
|
|
});
|
|
|
|
it('should return null for non-existent subagent', async () => {
|
|
vi.mocked(fs.readdir).mockRejectedValue(new Error('Directory not found'));
|
|
|
|
const metadata = await manager.findSubagentByName('nonexistent');
|
|
|
|
expect(metadata).toBeNull();
|
|
});
|
|
});
|
|
|
|
describe('isNameAvailable', () => {
|
|
it('should return true for available names', async () => {
|
|
vi.mocked(fs.readdir).mockRejectedValue(new Error('Directory not found'));
|
|
|
|
const available = await manager.isNameAvailable('new-agent');
|
|
|
|
expect(available).toBe(true);
|
|
});
|
|
|
|
it('should return false for existing names', async () => {
|
|
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
vi.mocked(fs.readdir).mockResolvedValue(['test-agent.md'] as any);
|
|
vi.mocked(fs.readFile).mockResolvedValue(validMarkdown);
|
|
|
|
const available = await manager.isNameAvailable('test-agent');
|
|
|
|
expect(available).toBe(false);
|
|
});
|
|
|
|
it('should check specific level when provided', async () => {
|
|
// The isNameAvailable method loads from both levels and checks if found subagent is at different level
|
|
// First call: loads subagent (found at user level), checks if it's at project level (different) -> available
|
|
vi.mocked(fs.readdir)
|
|
.mockRejectedValueOnce(new Error('Project dir not found')) // project level
|
|
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
.mockResolvedValueOnce(['test-agent.md'] as any); // user level - found here
|
|
vi.mocked(fs.readFile).mockResolvedValue(validMarkdown);
|
|
|
|
const availableAtProject = await manager.isNameAvailable(
|
|
'test-agent',
|
|
'project',
|
|
);
|
|
expect(availableAtProject).toBe(true); // Available at project because found at user level
|
|
|
|
// Second call: loads subagent (found at user level), checks if it's at user level (same) -> not available
|
|
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
vi.mocked(fs.readdir).mockResolvedValue(['test-agent.md'] as any); // user level - found here
|
|
vi.mocked(fs.readFile).mockResolvedValue(validMarkdown);
|
|
|
|
const availableAtUser = await manager.isNameAvailable(
|
|
'test-agent',
|
|
'user',
|
|
);
|
|
expect(availableAtUser).toBe(false); // Not available at user because found at user level
|
|
});
|
|
});
|
|
|
|
describe('Runtime Configuration Methods', () => {
|
|
describe('convertToRuntimeConfig', () => {
|
|
it('should convert basic configuration', () => {
|
|
const runtimeConfig = manager.convertToRuntimeConfig(validConfig);
|
|
|
|
expect(runtimeConfig.promptConfig.systemPrompt).toBe(
|
|
validConfig.systemPrompt,
|
|
);
|
|
expect(runtimeConfig.modelConfig).toEqual({});
|
|
expect(runtimeConfig.runConfig).toEqual({});
|
|
expect(runtimeConfig.toolConfig).toBeUndefined();
|
|
});
|
|
|
|
it('should include tool configuration when tools are specified', () => {
|
|
const configWithTools: SubagentConfig = {
|
|
...validConfig,
|
|
tools: ['read_file', 'write_file'],
|
|
};
|
|
|
|
const runtimeConfig = manager.convertToRuntimeConfig(configWithTools);
|
|
|
|
expect(runtimeConfig.toolConfig).toBeDefined();
|
|
expect(runtimeConfig.toolConfig!.tools).toEqual([
|
|
'read_file',
|
|
'write_file',
|
|
]);
|
|
});
|
|
|
|
it('should transform display names to tool names in tool configuration', () => {
|
|
const configWithDisplayNames: SubagentConfig = {
|
|
...validConfig,
|
|
tools: ['Read File', 'write_file', 'Search Files', 'unknown_tool'],
|
|
};
|
|
|
|
const runtimeConfig = manager.convertToRuntimeConfig(
|
|
configWithDisplayNames,
|
|
);
|
|
|
|
expect(runtimeConfig.toolConfig).toBeDefined();
|
|
expect(runtimeConfig.toolConfig!.tools).toEqual([
|
|
'read_file', // 'Read File' -> 'read_file' (display name match)
|
|
'write_file', // 'write_file' -> 'write_file' (exact name match)
|
|
'grep', // 'Search Files' -> 'grep' (display name match)
|
|
'unknown_tool', // 'unknown_tool' -> 'unknown_tool' (preserved as-is)
|
|
]);
|
|
});
|
|
|
|
it('should merge custom model and run configurations', () => {
|
|
const configWithCustom: SubagentConfig = {
|
|
...validConfig,
|
|
modelConfig: { model: 'custom-model', temp: 0.5 },
|
|
runConfig: { max_time_minutes: 5 },
|
|
};
|
|
|
|
const runtimeConfig = manager.convertToRuntimeConfig(configWithCustom);
|
|
|
|
expect(runtimeConfig.modelConfig.model).toBe('custom-model');
|
|
expect(runtimeConfig.modelConfig.temp).toBe(0.5);
|
|
expect(runtimeConfig.runConfig.max_time_minutes).toBe(5);
|
|
// No default values are provided anymore
|
|
expect(Object.keys(runtimeConfig.modelConfig)).toEqual([
|
|
'model',
|
|
'temp',
|
|
]);
|
|
expect(Object.keys(runtimeConfig.runConfig)).toEqual([
|
|
'max_time_minutes',
|
|
]);
|
|
});
|
|
});
|
|
|
|
describe('mergeConfigurations', () => {
|
|
it('should merge basic properties', () => {
|
|
const updates = {
|
|
description: 'Updated description',
|
|
systemPrompt: 'Updated prompt',
|
|
};
|
|
|
|
const merged = manager.mergeConfigurations(validConfig, updates);
|
|
|
|
expect(merged.description).toBe('Updated description');
|
|
expect(merged.systemPrompt).toBe('Updated prompt');
|
|
expect(merged.name).toBe(validConfig.name); // Should keep original
|
|
});
|
|
|
|
it('should merge nested configurations', () => {
|
|
const configWithNested: SubagentConfig = {
|
|
...validConfig,
|
|
modelConfig: { model: 'original-model', temp: 0.7 },
|
|
runConfig: { max_time_minutes: 10, max_turns: 20 },
|
|
};
|
|
|
|
const updates = {
|
|
modelConfig: { temp: 0.5 },
|
|
runConfig: { max_time_minutes: 5 },
|
|
};
|
|
|
|
const merged = manager.mergeConfigurations(configWithNested, updates);
|
|
|
|
expect(merged.modelConfig!.model).toBe('original-model'); // Should keep original
|
|
expect(merged.modelConfig!.temp).toBe(0.5); // Should update
|
|
expect(merged.runConfig!.max_time_minutes).toBe(5); // Should update
|
|
expect(merged.runConfig!.max_turns).toBe(20); // Should keep original
|
|
});
|
|
});
|
|
});
|
|
});
|