mirror of
https://github.com/affaan-m/ECC.git
synced 2026-10-14 20:25:26 +02:00
561 lines
22 KiB
JavaScript
561 lines
22 KiB
JavaScript
/**
|
|
* Tests for scripts/qwen-adapt-agents.js
|
|
*/
|
|
|
|
const assert = require('assert');
|
|
const fs = require('fs');
|
|
const os = require('os');
|
|
const path = require('path');
|
|
const { execFileSync } = require('child_process');
|
|
|
|
const SCRIPT = path.join(__dirname, '..', '..', 'scripts', 'qwen-adapt-agents.js');
|
|
|
|
function run(args = [], options = {}) {
|
|
try {
|
|
const stdout = execFileSync('node', [SCRIPT, ...args], {
|
|
encoding: 'utf8',
|
|
stdio: ['pipe', 'pipe', 'pipe'],
|
|
cwd: options.cwd,
|
|
timeout: 10000,
|
|
});
|
|
return { code: 0, stdout, stderr: '' };
|
|
} catch (error) {
|
|
return {
|
|
code: error.status || 1,
|
|
stdout: error.stdout || '',
|
|
stderr: error.stderr || '',
|
|
};
|
|
}
|
|
}
|
|
|
|
function test(name, fn) {
|
|
try {
|
|
fn();
|
|
console.log(` ✓ ${name}`);
|
|
return true;
|
|
} catch (error) {
|
|
console.log(` ✗ ${name}`);
|
|
console.log(` Error: ${error.message}`);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
function createTempDir() {
|
|
return fs.mkdtempSync(path.join(os.tmpdir(), 'ecc-qwen-adapt-'));
|
|
}
|
|
|
|
function cleanupTempDir(dirPath) {
|
|
fs.rmSync(dirPath, { recursive: true, force: true });
|
|
}
|
|
|
|
function writeAgent(dirPath, name, body) {
|
|
fs.mkdirSync(dirPath, { recursive: true });
|
|
fs.writeFileSync(path.join(dirPath, name), body);
|
|
}
|
|
|
|
function readAgent(dirPath, name) {
|
|
return fs.readFileSync(path.join(dirPath, name), 'utf8');
|
|
}
|
|
|
|
function runTests() {
|
|
console.log('\n=== Testing qwen-adapt-agents.js ===\n');
|
|
|
|
let passed = 0;
|
|
let failed = 0;
|
|
|
|
if (test('shows help with an explicit help flag', () => {
|
|
const result = run(['--help']);
|
|
assert.strictEqual(result.code, 0, result.stderr);
|
|
assert.ok(result.stdout.includes('Adapt ECC agent frontmatter for Qwen Code'));
|
|
assert.ok(result.stdout.includes('Usage:'));
|
|
})) passed++; else failed++;
|
|
|
|
if (test('maps Claude Code tool names to Qwen Code ids', () => {
|
|
const tempDir = createTempDir();
|
|
const agentsDir = path.join(tempDir, '.qwen', 'agents');
|
|
|
|
try {
|
|
writeAgent(
|
|
agentsDir,
|
|
'gan-planner.md',
|
|
[
|
|
'---',
|
|
'name: gan-planner',
|
|
'description: Planner agent',
|
|
'tools: [Read, Write, Edit, Bash, Grep, Glob, WebSearch, WebFetch]',
|
|
'model: opus',
|
|
'---',
|
|
'',
|
|
'Body'
|
|
].join('\n')
|
|
);
|
|
|
|
const result = run([agentsDir]);
|
|
assert.strictEqual(result.code, 0, result.stderr);
|
|
assert.ok(result.stdout.includes('Updated 1 agent file(s)'));
|
|
|
|
const updated = readAgent(agentsDir, 'gan-planner.md');
|
|
// Edit maps to `edit`, not Gemini's `replace`. WebSearch maps to
|
|
// `web_search`, not Gemini's `google_web_search`.
|
|
assert.ok(updated.includes('tools: read_file, write_file, edit, run_shell_command, grep_search, glob, web_search, web_fetch'));
|
|
assert.ok(updated.includes('model: inherit'));
|
|
assert.ok(!updated.includes('model: opus'));
|
|
assert.ok(!updated.includes('WebSearch'));
|
|
assert.ok(!updated.includes('WebFetch'));
|
|
} finally {
|
|
cleanupTempDir(tempDir);
|
|
}
|
|
})) passed++; else failed++;
|
|
|
|
if (test('preserves the mcp__server__tool shape', () => {
|
|
const tempDir = createTempDir();
|
|
const agentsDir = path.join(tempDir, '.qwen', 'agents');
|
|
|
|
try {
|
|
writeAgent(
|
|
agentsDir,
|
|
'docs-lookup.md',
|
|
[
|
|
'---',
|
|
'name: docs-lookup',
|
|
'description: Documentation lookup agent',
|
|
'tools: Read, Grep, mcp__context7__resolve-library-id, mcp__context7__query-docs',
|
|
'model: sonnet',
|
|
'---',
|
|
'',
|
|
'Body'
|
|
].join('\n')
|
|
);
|
|
|
|
const result = run([agentsDir]);
|
|
assert.strictEqual(result.code, 0, result.stderr);
|
|
|
|
const updated = readAgent(agentsDir, 'docs-lookup.md');
|
|
// Unlike Gemini, which lowercases these to mcp_context7_resolve_library_id,
|
|
// Qwen Code keeps the double-underscore form.
|
|
assert.ok(updated.includes('tools: read_file, grep_search, mcp__context7__resolve-library-id, mcp__context7__query-docs'));
|
|
} finally {
|
|
cleanupTempDir(tempDir);
|
|
}
|
|
})) passed++; else failed++;
|
|
|
|
if (test('deduplicates MultiEdit and Edit onto a single edit entry', () => {
|
|
const tempDir = createTempDir();
|
|
const agentsDir = path.join(tempDir, '.qwen', 'agents');
|
|
|
|
try {
|
|
writeAgent(
|
|
agentsDir,
|
|
'code-simplifier.md',
|
|
[
|
|
'---',
|
|
'name: code-simplifier',
|
|
'description: Refactoring agent',
|
|
'tools: Read, Edit, MultiEdit, Write',
|
|
'---',
|
|
'',
|
|
'Body'
|
|
].join('\n')
|
|
);
|
|
|
|
const result = run([agentsDir]);
|
|
assert.strictEqual(result.code, 0, result.stderr);
|
|
|
|
const updated = readAgent(agentsDir, 'code-simplifier.md');
|
|
assert.ok(updated.includes('tools: read_file, edit, write_file'));
|
|
assert.strictEqual(updated.split('edit').length - 1, 1);
|
|
} finally {
|
|
cleanupTempDir(tempDir);
|
|
}
|
|
})) passed++; else failed++;
|
|
|
|
if (test('remaps an out-of-palette color instead of dropping it', () => {
|
|
const tempDir = createTempDir();
|
|
const agentsDir = path.join(tempDir, '.qwen', 'agents');
|
|
|
|
try {
|
|
writeAgent(
|
|
agentsDir,
|
|
'harness-optimizer.md',
|
|
[
|
|
'---',
|
|
'name: harness-optimizer',
|
|
'description: Harness tuning agent',
|
|
'tools: Read, Grep',
|
|
'color: teal',
|
|
'---',
|
|
'',
|
|
'Body'
|
|
].join('\n')
|
|
);
|
|
|
|
const result = run([agentsDir]);
|
|
assert.strictEqual(result.code, 0, result.stderr);
|
|
|
|
// Qwen Code supports color:, but only red/blue/green/yellow/purple/orange/
|
|
// pink/cyan/auto. An unlisted value is dropped at load time with a
|
|
// warning, so teal is remapped to its nearest valid equivalent.
|
|
const updated = readAgent(agentsDir, 'harness-optimizer.md');
|
|
assert.ok(updated.includes('color: cyan'));
|
|
assert.ok(!updated.includes('color: teal'));
|
|
} finally {
|
|
cleanupTempDir(tempDir);
|
|
}
|
|
})) passed++; else failed++;
|
|
|
|
if (test('adapts color with long whitespace through the actual CLI', () => {
|
|
const tempDir = createTempDir();
|
|
try {
|
|
const tabs = '\t'.repeat(250000);
|
|
writeAgent(tempDir, 'color.md', ['---', 'name: color', 'tools: Read', `color:${tabs}teal${tabs}`, '---', 'BODY'].join('\n'));
|
|
const result = run([tempDir]);
|
|
assert.strictEqual(result.code, 0, result.stderr);
|
|
assert.ok(readAgent(tempDir, 'color.md').includes('color: cyan'));
|
|
const before = readAgent(tempDir, 'color.md');
|
|
assert.strictEqual(run([tempDir]).code, 0);
|
|
assert.strictEqual(readAgent(tempDir, 'color.md'), before);
|
|
} finally { cleanupTempDir(tempDir); }
|
|
})) passed++; else failed++;
|
|
|
|
if (test('leaves an already-compatible agent untouched', () => {
|
|
const tempDir = createTempDir();
|
|
const agentsDir = path.join(tempDir, '.qwen', 'agents');
|
|
|
|
try {
|
|
writeAgent(
|
|
agentsDir,
|
|
'security-reviewer.md',
|
|
[
|
|
'---',
|
|
'name: security-reviewer',
|
|
'description: Security agent',
|
|
'tools: read_file, grep_search',
|
|
'color: red',
|
|
'---',
|
|
'',
|
|
'Body'
|
|
].join('\n')
|
|
);
|
|
|
|
const before = readAgent(agentsDir, 'security-reviewer.md');
|
|
const result = run([agentsDir]);
|
|
assert.strictEqual(result.code, 0, result.stderr);
|
|
assert.ok(result.stdout.includes('Updated 0 agent file(s)'));
|
|
assert.ok(result.stdout.includes('1 already compatible'));
|
|
// A color inside the palette and Qwen-native tool ids need no rewrite.
|
|
assert.strictEqual(readAgent(agentsDir, 'security-reviewer.md'), before);
|
|
} finally {
|
|
cleanupTempDir(tempDir);
|
|
}
|
|
})) passed++; else failed++;
|
|
|
|
if (test('leaves the agent body untouched', () => {
|
|
const tempDir = createTempDir();
|
|
const agentsDir = path.join(tempDir, '.qwen', 'agents');
|
|
const body = ['', 'Read the codebase, then Write a summary.', 'Use Bash only when needed.'].join('\n');
|
|
|
|
try {
|
|
writeAgent(
|
|
agentsDir,
|
|
'code-explorer.md',
|
|
['---', 'name: code-explorer', 'tools: Read, Bash', '---', body].join('\n')
|
|
);
|
|
|
|
const result = run([agentsDir]);
|
|
assert.strictEqual(result.code, 0, result.stderr);
|
|
|
|
const updated = readAgent(agentsDir, 'code-explorer.md');
|
|
// Prose that names Claude tools must survive: only frontmatter is in scope.
|
|
assert.ok(updated.endsWith(body));
|
|
} finally {
|
|
cleanupTempDir(tempDir);
|
|
}
|
|
})) passed++; else failed++;
|
|
|
|
if (test('is idempotent on a second run', () => {
|
|
const tempDir = createTempDir();
|
|
const agentsDir = path.join(tempDir, '.qwen', 'agents');
|
|
|
|
try {
|
|
writeAgent(
|
|
agentsDir,
|
|
'architect.md',
|
|
['---', 'name: architect', 'tools: Read, Grep, Glob', 'color: teal', '---', '', 'Body'].join('\n')
|
|
);
|
|
|
|
const first = run([agentsDir]);
|
|
assert.strictEqual(first.code, 0, first.stderr);
|
|
assert.ok(first.stdout.includes('Updated 1 agent file(s)'));
|
|
const afterFirst = readAgent(agentsDir, 'architect.md');
|
|
|
|
const second = run([agentsDir]);
|
|
assert.strictEqual(second.code, 0, second.stderr);
|
|
assert.ok(second.stdout.includes('Updated 0 agent file(s)'));
|
|
assert.ok(second.stdout.includes('1 already compatible'));
|
|
assert.strictEqual(readAgent(agentsDir, 'architect.md'), afterFirst);
|
|
} finally {
|
|
cleanupTempDir(tempDir);
|
|
}
|
|
})) passed++; else failed++;
|
|
|
|
if (test('defaults to the cwd .qwen/agents directory', () => {
|
|
const tempDir = createTempDir();
|
|
const agentsDir = path.join(tempDir, '.qwen', 'agents');
|
|
|
|
try {
|
|
writeAgent(
|
|
agentsDir,
|
|
'planner.md',
|
|
['---', 'name: planner', 'tools: ["Read", "Grep", "Glob"]', '---', '', 'Body'].join('\n')
|
|
);
|
|
|
|
const result = run([], { cwd: tempDir });
|
|
assert.strictEqual(result.code, 0, result.stderr);
|
|
assert.ok(readAgent(agentsDir, 'planner.md').includes('tools: read_file, grep_search, glob'));
|
|
} finally {
|
|
cleanupTempDir(tempDir);
|
|
}
|
|
})) passed++; else failed++;
|
|
|
|
if (test('fails with a clear error when the agents directory is missing', () => {
|
|
const tempDir = createTempDir();
|
|
|
|
try {
|
|
const result = run([path.join(tempDir, 'nope')]);
|
|
assert.strictEqual(result.code, 1);
|
|
assert.ok(result.stderr.includes('Agents directory not found'));
|
|
} finally {
|
|
cleanupTempDir(tempDir);
|
|
}
|
|
})) passed++; else failed++;
|
|
|
|
if (test('adapts a CRLF agent and preserves its line endings', () => {
|
|
const tempDir = createTempDir();
|
|
const agentsDir = path.join(tempDir, '.qwen', 'agents');
|
|
|
|
try {
|
|
writeAgent(
|
|
agentsDir,
|
|
'windows.md',
|
|
['---', 'name: windows', 'tools: Read, Bash', 'color: teal', '---', '', 'Body line'].join('\r\n')
|
|
);
|
|
|
|
const result = run([agentsDir]);
|
|
assert.strictEqual(result.code, 0, result.stderr);
|
|
// A CRLF-only match used to report "already compatible" while leaving
|
|
// Read/Bash/teal in place, so assert the update actually happened.
|
|
assert.ok(result.stdout.includes('Updated 1 agent file(s)'), result.stdout);
|
|
|
|
const updated = readAgent(agentsDir, 'windows.md');
|
|
assert.ok(updated.includes('tools: read_file, run_shell_command'));
|
|
assert.ok(updated.includes('color: cyan'));
|
|
assert.ok(!updated.includes('Read,'));
|
|
assert.ok(updated.includes('\r\n'), 'CRLF endings were lost');
|
|
assert.ok(!/[^\r]\n/.test(updated), 'found a bare LF in a CRLF file');
|
|
} finally {
|
|
cleanupTempDir(tempDir);
|
|
}
|
|
})) passed++; else failed++;
|
|
|
|
if (test('rejects an unknown flag without modifying any file', () => {
|
|
const tempDir = createTempDir();
|
|
const agentsDir = path.join(tempDir, '.qwen', 'agents');
|
|
|
|
try {
|
|
writeAgent(
|
|
agentsDir,
|
|
'architect.md',
|
|
['---', 'name: architect', 'tools: Read, Bash', '---', '', 'Body'].join('\n')
|
|
);
|
|
const before = readAgent(agentsDir, 'architect.md');
|
|
|
|
const result = run(['--dry-run', agentsDir]);
|
|
assert.strictEqual(result.code, 1);
|
|
assert.ok(result.stderr.includes('Unknown option: --dry-run'), result.stderr);
|
|
// The point of rejecting: a flag that looks like a preview must not
|
|
// rewrite installed agents and still exit 0.
|
|
assert.strictEqual(readAgent(agentsDir, 'architect.md'), before);
|
|
} finally {
|
|
cleanupTempDir(tempDir);
|
|
}
|
|
})) passed++; else failed++;
|
|
|
|
if (test('rejects an empty allowlist before writing any agent in the CLI batch', () => {
|
|
const tempDir = createTempDir();
|
|
const agentsDir = path.join(tempDir, '.qwen', 'agents');
|
|
try {
|
|
for (const emptyTools of ['[]', '[] # no tools', '', 'null', '""']) {
|
|
writeAgent(agentsDir, 'a-valid.md', ['---', 'name: valid', 'tools: Read', 'model: sonnet', '---', 'VALID_BODY'].join('\n'));
|
|
writeAgent(agentsDir, 'z-no-tools.md', ['---', 'name: no-tools', `tools: ${emptyTools}`, 'model: sonnet', '---', 'NO_TOOLS_BODY'].join('\n'));
|
|
writeAgent(agentsDir, 'ignored.txt', 'UNCHANGED');
|
|
const snapshot = () => fs.readdirSync(agentsDir).sort().map(name => [name, fs.readFileSync(path.join(agentsDir, name)).toString('base64')]);
|
|
const before = snapshot();
|
|
for (let attempt = 0; attempt < 2; attempt++) {
|
|
const result = run([agentsDir]);
|
|
assert.strictEqual(result.code, 1, result.stdout);
|
|
assert.match(result.stderr, /z-no-tools.md: Unsupported empty tools allowlist/);
|
|
assert.match(result.stderr, /inherits all tools/);
|
|
assert.deepStrictEqual(snapshot(), before);
|
|
}
|
|
}
|
|
} finally { cleanupTempDir(tempDir); }
|
|
})) passed++; else failed++;
|
|
|
|
if (test('adapts a nonempty YAML block list without leftover tool entries', () => {
|
|
const { adaptFrontmatter } = require(SCRIPT);
|
|
const yaml = require('js-yaml');
|
|
const result = adaptFrontmatter(['---', 'name: block-tools', 'description: Neighbor metadata', 'tools:', ' - Read', '', '# Tool list comment', ' - Grep', 'model: sonnet', 'metadata:', ' owner: operator', '---', 'BODY'].join('\n'));
|
|
const parsed = yaml.load(result.text.match(/^---\n([\s\S]*?)\n---/)[1]);
|
|
assert.strictEqual(parsed.tools, 'read_file, grep_search');
|
|
assert.strictEqual(parsed.model, 'inherit');
|
|
assert.strictEqual(parsed.description, 'Neighbor metadata');
|
|
assert.deepStrictEqual(parsed.metadata, { owner: 'operator' });
|
|
assert.strictEqual(adaptFrontmatter(result.text).changed, false);
|
|
})) passed++; else failed++;
|
|
|
|
if (test('converts indentless tool sequences through the actual CLI without changing neighboring metadata', () => {
|
|
const tempDir = createTempDir();
|
|
const yaml = require('js-yaml');
|
|
try {
|
|
for (const [name, items] of [['plain.md', '- Read\n- Grep'], ['comments.md', '- Read\n# Keep the list valid\n- Grep']]) {
|
|
writeAgent(tempDir, name, [
|
|
'---', `name: ${name.slice(0, -3)}`, 'description: Preserve neighboring metadata',
|
|
'metadata:', ' color: teal', ' owner: operator',
|
|
'tools:', items, 'model: sonnet', '---', 'BODY_SENTINEL',
|
|
].join('\n'));
|
|
}
|
|
const first = run([tempDir]);
|
|
assert.strictEqual(first.code, 0, first.stderr);
|
|
const beforeRerun = fs.readdirSync(tempDir).sort().map(name => [name, readAgent(tempDir, name)]);
|
|
for (const [, text] of beforeRerun) {
|
|
const parsed = yaml.load(text.match(/^---\n([\s\S]*?)\n---/)[1]);
|
|
assert.strictEqual(parsed.tools, 'read_file, grep_search');
|
|
assert.strictEqual(parsed.model, 'inherit');
|
|
assert.strictEqual(parsed.description, 'Preserve neighboring metadata');
|
|
assert.deepStrictEqual(parsed.metadata, { color: 'teal', owner: 'operator' });
|
|
assert.ok(text.endsWith('BODY_SENTINEL'));
|
|
}
|
|
assert.strictEqual(run([tempDir]).code, 0);
|
|
assert.deepStrictEqual(fs.readdirSync(tempDir).sort().map(name => [name, readAgent(tempDir, name)]), beforeRerun);
|
|
} finally { cleanupTempDir(tempDir); }
|
|
})) passed++; else failed++;
|
|
|
|
if (test('a real managed plan installs parseable indentless tool sequences', () => {
|
|
const { createManifestInstallPlan, previewInstallPlan, applyInstallPlan } = require('../../scripts/lib/install-executor');
|
|
const yaml = require('js-yaml');
|
|
const tempDir = createTempDir();
|
|
try {
|
|
const plan = createManifestInstallPlan({
|
|
sourceRoot: path.join(__dirname, '..', '..'), target: 'qwen',
|
|
homeDir: path.join(tempDir, 'home'), projectRoot: tempDir,
|
|
moduleIds: ['agents-core'], env: { HOME: path.join(tempDir, 'home') },
|
|
});
|
|
const operation = plan.operations.find(item => item.contentTransform === 'qwen-agent-frontmatter');
|
|
assert.ok(operation);
|
|
const source = path.join(tempDir, 'source.md');
|
|
fs.writeFileSync(source, ['---', 'name: sequence', 'description: Valid tools',
|
|
'tools:', '- Read', '- Grep', 'model: sonnet', '---', 'MANAGED_BODY'].join('\n'));
|
|
operation.sourcePath = source;
|
|
previewInstallPlan(plan);
|
|
applyInstallPlan(plan);
|
|
const installed = fs.readFileSync(operation.destinationPath, 'utf8');
|
|
const parsed = yaml.load(installed.match(/^---\n([\s\S]*?)\n---/)[1]);
|
|
assert.strictEqual(parsed.tools, 'read_file, grep_search');
|
|
assert.strictEqual(parsed.model, 'inherit');
|
|
assert.ok(installed.endsWith('MANAGED_BODY'));
|
|
assert.ok(fs.existsSync(plan.installStatePath));
|
|
} finally { cleanupTempDir(tempDir); }
|
|
})) passed++; else failed++;
|
|
|
|
if (test('rejects an invalid converted alias before changing any standalone file', () => {
|
|
const tempDir = createTempDir();
|
|
try {
|
|
writeAgent(tempDir, 'a-valid.md', ['---', 'name: valid', 'tools: Read', '---', 'BODY'].join('\n'));
|
|
writeAgent(tempDir, 'z-alias.md', ['---', 'name: alias', 'tools: &allowed', '- Read',
|
|
'metadata:', ' allowed: *allowed', '---', 'ALIAS_BODY'].join('\n'));
|
|
const before = fs.readdirSync(tempDir).sort().map(name => [name, readAgent(tempDir, name)]);
|
|
const result = run([tempDir]);
|
|
assert.strictEqual(result.code, 1);
|
|
assert.match(result.stderr, /transformed YAML is invalid/);
|
|
assert.deepStrictEqual(fs.readdirSync(tempDir).sort().map(name => [name, readAgent(tempDir, name)]), before);
|
|
} finally { cleanupTempDir(tempDir); }
|
|
})) passed++; else failed++;
|
|
|
|
if (test('rejects uniformly indented mappings without changing neighboring metadata', () => {
|
|
const tempDir = createTempDir();
|
|
try {
|
|
const source = ['---', ' name: indented', ' description: Preserve me', ' tools:', ' - Read', ' - Grep', ' model: sonnet', '---', 'BODY'].join('\n');
|
|
writeAgent(tempDir, 'indented.md', source);
|
|
for (let attempt = 0; attempt < 2; attempt++) {
|
|
const result = run([tempDir]);
|
|
assert.strictEqual(result.code, 1);
|
|
assert.match(result.stderr, /Unsupported indented Qwen agent frontmatter/);
|
|
assert.strictEqual(readAgent(tempDir, 'indented.md'), source);
|
|
}
|
|
} finally { cleanupTempDir(tempDir); }
|
|
})) passed++; else failed++;
|
|
|
|
if (test('preflights every managed Qwen transform before file or receipt writes', () => {
|
|
const { applyInstallPlan, previewInstallPlan } = require('../../scripts/lib/install/apply');
|
|
const tempDir = createTempDir();
|
|
const targetRoot = path.join(tempDir, 'installed');
|
|
const sourceRoot = path.join(tempDir, 'source');
|
|
try {
|
|
fs.mkdirSync(targetRoot);
|
|
fs.mkdirSync(sourceRoot);
|
|
const valid = ['---', 'name: valid', 'tools: Read', '---', 'BODY'].join('\n');
|
|
const invalid = ['---', 'name: invalid', 'tools: []', '---', 'BODY'].join('\n');
|
|
writeAgent(sourceRoot, 'a-valid.md', valid);
|
|
writeAgent(sourceRoot, 'z-invalid.md', invalid);
|
|
writeAgent(targetRoot, 'z-invalid.md', 'OPERATOR_OWNED_BYTES');
|
|
writeAgent(targetRoot, 'ecc-install-state.json', '{"preserve":"receipt"}');
|
|
const plan = {
|
|
adapter: { id: 'qwen-home', target: 'qwen' },
|
|
targetRoot,
|
|
installStatePath: path.join(targetRoot, 'ecc-install-state.json'),
|
|
operations: ['a-valid.md', 'z-invalid.md'].map(name => ({
|
|
kind: 'copy-file', sourcePath: path.join(sourceRoot, name),
|
|
sourceRelativePath: `agents/${name}`,
|
|
destinationPath: path.join(targetRoot, name),
|
|
contentTransform: 'qwen-agent-frontmatter',
|
|
})),
|
|
};
|
|
const snapshot = () => fs.readdirSync(targetRoot).sort().map(name => [name, fs.readFileSync(path.join(targetRoot, name)).toString('base64')]);
|
|
const before = snapshot();
|
|
for (const operation of [previewInstallPlan, applyInstallPlan]) {
|
|
assert.throws(() => operation(plan), /Unsupported empty tools allowlist/);
|
|
assert.deepStrictEqual(snapshot(), before);
|
|
}
|
|
fs.unlinkSync(path.join(sourceRoot, 'z-invalid.md'));
|
|
fs.mkdirSync(path.join(sourceRoot, 'z-invalid.md'));
|
|
assert.throws(() => applyInstallPlan(plan), /non-regular source file/);
|
|
assert.deepStrictEqual(snapshot(), before);
|
|
} finally { cleanupTempDir(tempDir); }
|
|
})) passed++; else failed++;
|
|
|
|
if (test('keeps an absent tools field absent through CLI adaptation and rerun', () => {
|
|
const tempDir = createTempDir();
|
|
const agentsDir = path.join(tempDir, '.qwen', 'agents');
|
|
const yaml = require('js-yaml');
|
|
try {
|
|
writeAgent(agentsDir, 'inherit-tools.md', [
|
|
'---', 'name: inherit-tools', 'description: Uses parent tools',
|
|
'model: sonnet', '---', '', 'BODY_SENTINEL'
|
|
].join('\n'));
|
|
const first = run([agentsDir]);
|
|
assert.strictEqual(first.code, 0, first.stderr);
|
|
const adapted = readAgent(agentsDir, 'inherit-tools.md');
|
|
const parsed = yaml.load(adapted.match(/^---\n([\s\S]*?)\n---/)[1]);
|
|
assert.strictEqual(Object.hasOwn(parsed, 'tools'), false);
|
|
const second = run([agentsDir]);
|
|
assert.strictEqual(second.code, 0, second.stderr);
|
|
assert.strictEqual(readAgent(agentsDir, 'inherit-tools.md'), adapted);
|
|
} finally { cleanupTempDir(tempDir); }
|
|
})) passed++; else failed++;
|
|
|
|
console.log(`\nResults: Passed: ${passed}, Failed: ${failed}`);
|
|
process.exit(failed > 0 ? 1 : 0);
|
|
}
|
|
|
|
runTests();
|