mirror of
https://github.com/affaan-m/ECC.git
synced 2026-10-14 12:15:29 +02:00
359 lines
17 KiB
JavaScript
359 lines
17 KiB
JavaScript
#!/usr/bin/env node
|
|
|
|
'use strict';
|
|
|
|
const assert = require('assert');
|
|
const fs = require('fs');
|
|
const os = require('os');
|
|
const path = require('path');
|
|
const { spawnSync } = require('child_process');
|
|
|
|
const repoRoot = path.resolve(__dirname, '..', '..');
|
|
const scanScript = path.join(repoRoot, 'skills', 'skill-stocktake', 'scripts', 'scan.sh');
|
|
const quickDiffScript = path.join(repoRoot, 'skills', 'skill-stocktake', 'scripts', 'quick-diff.sh');
|
|
|
|
let passed = 0;
|
|
let failed = 0;
|
|
|
|
function test(description, fn) {
|
|
try {
|
|
fn();
|
|
console.log(` ✓ ${description}`);
|
|
passed++;
|
|
} catch (error) {
|
|
console.log(` ✗ ${description}: ${error.message}`);
|
|
failed++;
|
|
}
|
|
}
|
|
|
|
function writeSkill(skillDir, name) {
|
|
fs.mkdirSync(skillDir, { recursive: true });
|
|
fs.writeFileSync(
|
|
path.join(skillDir, 'SKILL.md'),
|
|
`---\nname: ${name}\ndescription: test fixture\n---\n# ${name}\n`,
|
|
);
|
|
}
|
|
|
|
function runBash(scriptPath, args, env) {
|
|
return spawnSync('bash', [scriptPath, ...args], {
|
|
encoding: 'utf8',
|
|
env: { ...process.env, ...env },
|
|
});
|
|
}
|
|
|
|
console.log('\nSkill stocktake discovery tests:');
|
|
|
|
test('both scanners use canonical, error-visible, NUL-delimited discovery', () => {
|
|
for (const scriptPath of [scanScript, quickDiffScript]) {
|
|
const source = fs.readFileSync(scriptPath, 'utf8');
|
|
assert.match(source, /find -L "\$dir"/);
|
|
assert.match(source, /-name "SKILL\.md" -type f -print0/);
|
|
assert.match(source, /sort_nul_file "\$find_out"/);
|
|
assert.match(source, /records\.sort\(Buffer\.compare\)/);
|
|
assert.doesNotMatch(source, /sort -z/, `${path.basename(scriptPath)} still requires GNU sort`);
|
|
assert.match(source, /read -r -d '' file/);
|
|
assert.doesNotMatch(source, /find [^\n]*2>\/dev\/null/, `${path.basename(scriptPath)} still hides find errors`);
|
|
}
|
|
});
|
|
|
|
if (process.platform === 'win32') {
|
|
console.log(' ↷ POSIX symlink and newline-path integration cases skipped on Windows');
|
|
} else {
|
|
const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'ecc-skill-stocktake-'));
|
|
try {
|
|
const projectSkills = path.join(tempRoot, 'project', '.claude', 'skills');
|
|
const directSkill = path.join(projectSkills, 'direct skill');
|
|
const linkedTarget = path.join(tempRoot, 'shared', 'linked-skill');
|
|
const newlineSkill = path.join(projectSkills, 'newline\nskill');
|
|
const resultsPath = path.join(tempRoot, 'results.json');
|
|
const observationsPath = path.join(tempRoot, 'observations.jsonl');
|
|
|
|
writeSkill(directSkill, 'direct-skill');
|
|
writeSkill(linkedTarget, 'linked-skill');
|
|
writeSkill(newlineSkill, 'newline-skill');
|
|
fs.symlinkSync(linkedTarget, path.join(projectSkills, 'linked-skill'), 'dir');
|
|
fs.mkdirSync(path.join(directSkill, 'references'), { recursive: true });
|
|
fs.writeFileSync(path.join(directSkill, 'references', 'notes.md'), '# supporting notes\n');
|
|
fs.writeFileSync(
|
|
resultsPath,
|
|
JSON.stringify({ evaluated_at: '2099-01-01T00:00:00Z', skills: [] }),
|
|
);
|
|
fs.writeFileSync(
|
|
observationsPath,
|
|
`${JSON.stringify({
|
|
tool: 'Read',
|
|
path: path.join(newlineSkill, 'SKILL.md'),
|
|
timestamp: new Date().toISOString(),
|
|
})}\n${JSON.stringify({
|
|
tool: 'Read',
|
|
path: path.join(directSkill, 'SKILL.md'),
|
|
timestamp: new Date().toISOString(),
|
|
})}\n`,
|
|
);
|
|
|
|
const env = {
|
|
SKILL_STOCKTAKE_GLOBAL_DIR: path.join(tempRoot, 'missing-global'),
|
|
SKILL_STOCKTAKE_PROJECT_DIR: projectSkills,
|
|
SKILL_STOCKTAKE_OBSERVATIONS: observationsPath,
|
|
};
|
|
|
|
test('scan follows symlinked skills and ignores nested Markdown assets', () => {
|
|
const result = runBash(scanScript, [], env);
|
|
assert.strictEqual(result.status, 0, result.stderr);
|
|
const output = JSON.parse(result.stdout);
|
|
assert.strictEqual(output.scan_summary.project.count, 3);
|
|
assert.deepStrictEqual(
|
|
output.skills.map(skill => skill.name).sort(),
|
|
['direct-skill', 'linked-skill', 'newline-skill'],
|
|
);
|
|
const newlineEntry = output.skills.find(skill => skill.name === 'newline-skill');
|
|
assert.strictEqual(newlineEntry.use_7d, 1);
|
|
assert.strictEqual(newlineEntry.use_30d, 1);
|
|
const spaceEntry = output.skills.find(skill => skill.name === 'direct-skill');
|
|
assert.strictEqual(spaceEntry.use_7d, 1);
|
|
assert.strictEqual(spaceEntry.use_30d, 1);
|
|
});
|
|
|
|
test('quick diff keeps newline-containing skill paths as one record', () => {
|
|
const result = runBash(quickDiffScript, [resultsPath], env);
|
|
assert.strictEqual(result.status, 0, result.stderr);
|
|
const output = JSON.parse(result.stdout);
|
|
assert.strictEqual(output.length, 3);
|
|
assert.strictEqual(
|
|
output.filter(entry => entry.path.includes('newline\nskill/SKILL.md')).length,
|
|
1,
|
|
);
|
|
assert.ok(output.every(entry => entry.is_new === true));
|
|
});
|
|
|
|
test('quick diff recognizes a cached newline-containing path', () => {
|
|
fs.writeFileSync(
|
|
resultsPath,
|
|
JSON.stringify({
|
|
evaluated_at: '2099-01-01T00:00:00Z',
|
|
skills: [{ path: path.join(newlineSkill, 'SKILL.md') }],
|
|
}),
|
|
);
|
|
const result = runBash(quickDiffScript, [resultsPath], env);
|
|
assert.strictEqual(result.status, 0, result.stderr);
|
|
const output = JSON.parse(result.stdout);
|
|
assert.strictEqual(output.length, 2);
|
|
assert.ok(output.every(entry => !entry.path.includes('newline\nskill/SKILL.md')));
|
|
});
|
|
} catch (error) {
|
|
console.log(` ✗ fixture setup: ${error.message}`);
|
|
failed++;
|
|
} finally {
|
|
fs.rmSync(tempRoot, { recursive: true, force: true });
|
|
}
|
|
}
|
|
|
|
if (process.platform !== 'win32') {
|
|
const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'ecc-stocktake-inventory-'));
|
|
try {
|
|
const globalSkills = path.join(tempRoot, 'global', '.claude', 'skills');
|
|
const projectSkills = path.join(tempRoot, 'project', '.claude', 'skills');
|
|
const liveSkills = [
|
|
[path.join(globalSkills, 'active'), 'global-active'],
|
|
[path.join(globalSkills, '.trash-archive'), 'global-trash-archive'],
|
|
[path.join(projectSkills, 'active'), 'project-active'],
|
|
[path.join(projectSkills, '.trashcan'), 'project-trashcan'],
|
|
[path.join(projectSkills, 'space skill'), 'space-skill'],
|
|
[path.join(projectSkills, 'newline\nskill'), 'newline-skill'],
|
|
];
|
|
for (const [skillDir, name] of liveSkills) writeSkill(skillDir, name);
|
|
for (const [scope, skillsDir] of [['global', globalSkills], ['project', projectSkills]]) {
|
|
writeSkill(path.join(skillsDir, '.trash', 'deleted'), `${scope}-deleted`);
|
|
writeSkill(path.join(skillsDir, 'bundle', '.trash', 'nested'), `${scope}-nested-deleted`);
|
|
}
|
|
const linkedTarget = path.join(tempRoot, 'shared', 'linked');
|
|
const linkedSkill = path.join(projectSkills, 'linked');
|
|
writeSkill(linkedTarget, 'linked-skill');
|
|
fs.symlinkSync(linkedTarget, linkedSkill, 'dir');
|
|
const expectedPaths = [...liveSkills.map(([skillDir]) => path.join(skillDir, 'SKILL.md')),
|
|
path.join(linkedSkill, 'SKILL.md')].sort();
|
|
const resultsPath = path.join(tempRoot, 'results.json');
|
|
fs.writeFileSync(resultsPath, JSON.stringify({ evaluated_at: '2099-01-01T00:00:00Z', skills: [] }));
|
|
const emptyObservations = path.join(tempRoot, 'empty-observations.jsonl');
|
|
fs.writeFileSync(emptyObservations, '');
|
|
const env = {
|
|
SKILL_STOCKTAKE_GLOBAL_DIR: globalSkills,
|
|
SKILL_STOCKTAKE_PROJECT_DIR: projectSkills,
|
|
SKILL_STOCKTAKE_OBSERVATIONS: path.join(tempRoot, 'missing-observations.jsonl'),
|
|
};
|
|
|
|
test('scan excludes root and nested .trash directories in both scopes, preserving live skills', () => {
|
|
const result = runBash(scanScript, [], env);
|
|
assert.strictEqual(result.status, 0, result.stderr);
|
|
const output = JSON.parse(result.stdout);
|
|
assert.deepStrictEqual(output.skills.map(skill => skill.path).sort(), expectedPaths);
|
|
assert.strictEqual(output.scan_summary.global.count, 2);
|
|
assert.strictEqual(output.scan_summary.project.count, 5);
|
|
});
|
|
|
|
test('quick diff excludes .trash in both scopes while preserving similarly named and linked skills', () => {
|
|
const result = runBash(quickDiffScript, [resultsPath], env);
|
|
assert.strictEqual(result.status, 0, result.stderr);
|
|
const output = JSON.parse(result.stdout);
|
|
assert.deepStrictEqual(output.map(skill => skill.path).sort(), expectedPaths);
|
|
assert.ok(output.every(skill => skill.is_new === true));
|
|
});
|
|
|
|
for (const [scope, skillsDir] of [['global', globalSkills], ['project', projectSkills]]) {
|
|
test(`scan rejects incomplete ${scope} discovery and cleans temporary files`, () => {
|
|
const binDir = path.join(tempRoot, `${scope}-bin`);
|
|
const scanTmp = path.join(tempRoot, `${scope}-scan-tmp`);
|
|
fs.mkdirSync(binDir);
|
|
fs.mkdirSync(scanTmp);
|
|
const findResult = spawnSync('bash', ['-c', 'command -v find'], { encoding: 'utf8' });
|
|
assert.strictEqual(findResult.status, 0, findResult.stderr);
|
|
const realFind = findResult.stdout.trim();
|
|
assert.ok(path.isAbsolute(realFind), 'Resolve the real find before overriding PATH');
|
|
// Directory cycles do not fail consistently across GNU and BSD find.
|
|
// Emit a real partial record, then fail only the selected scope.
|
|
fs.writeFileSync(path.join(binDir, 'find'), [
|
|
'#!/usr/bin/env bash',
|
|
'if [[ "$2" == "$ECC_TEST_FIND_DIR" ]]; then',
|
|
' printf "%s\\0" "$ECC_TEST_FIND_PARTIAL"',
|
|
' printf "fixture find failure: %s\\n" "$ECC_TEST_FIND_DIR" >&2',
|
|
' exit 1',
|
|
'fi',
|
|
'exec "$ECC_TEST_REAL_FIND" "$@"',
|
|
'',
|
|
].join('\n'), { mode: 0o755 });
|
|
const result = runBash(scanScript, [], {
|
|
...env, TMPDIR: scanTmp,
|
|
PATH: `${binDir}${path.delimiter}${process.env.PATH}`,
|
|
ECC_TEST_FIND_DIR: skillsDir,
|
|
ECC_TEST_FIND_PARTIAL: path.join(skillsDir, 'active', 'SKILL.md'),
|
|
ECC_TEST_REAL_FIND: realFind,
|
|
});
|
|
assert.strictEqual(result.status, 1, 'A failed find must not publish a partial inventory');
|
|
assert.strictEqual(result.stdout, '', 'Incomplete discovery must not produce inventory JSON');
|
|
assert.match(result.stderr, /Error: find encountered errors while scanning/);
|
|
assert.ok(result.stderr.includes(`fixture find failure: ${skillsDir}`), 'Preserve find stderr');
|
|
assert.deepStrictEqual(fs.readdirSync(scanTmp), [], 'Clean discovery files on failure');
|
|
});
|
|
}
|
|
|
|
for (const name of ['project-active', 'space-skill', 'newline-skill']) {
|
|
test(`scan reports unknown usage for ${name} when observations are missing`, () => {
|
|
const result = runBash(scanScript, [], env);
|
|
assert.strictEqual(result.status, 0, result.stderr);
|
|
const skill = JSON.parse(result.stdout).skills.find(entry => entry.name === name);
|
|
assert.ok(skill, `missing live skill: ${name}`);
|
|
assert.strictEqual(skill.use_7d, null);
|
|
assert.strictEqual(skill.use_30d, null);
|
|
});
|
|
}
|
|
|
|
test('scan reports numeric zero for unobserved skills when an empty observation file exists', () => {
|
|
const result = runBash(scanScript, [], { ...env, SKILL_STOCKTAKE_OBSERVATIONS: emptyObservations });
|
|
assert.strictEqual(result.status, 0, result.stderr);
|
|
const output = JSON.parse(result.stdout);
|
|
assert.ok(output.skills.length > 0);
|
|
for (const skill of output.skills) {
|
|
assert.strictEqual(skill.use_7d, 0, skill.path);
|
|
assert.strictEqual(skill.use_30d, 0, skill.path);
|
|
}
|
|
});
|
|
|
|
test('scan preserves exact usage counts and date windows for normal and whitespace paths', () => {
|
|
const observationsPath = path.join(tempRoot, 'matching-observations.jsonl');
|
|
const observedPaths = [path.join(linkedSkill, 'SKILL.md'),
|
|
...liveSkills.filter(([, name]) => ['space-skill', 'newline-skill'].includes(name))
|
|
.map(([skillDir]) => path.join(skillDir, 'SKILL.md'))];
|
|
const timestamp = days => new Date(Date.now() - days * 86400000).toISOString();
|
|
const observations = observedPaths.flatMap(skillPath => [
|
|
{ tool: 'Read', path: skillPath, timestamp: timestamp(0) },
|
|
{ tool: 'Read', path: skillPath, timestamp: timestamp(1) },
|
|
{ tool: 'Read', path: skillPath, timestamp: timestamp(10) },
|
|
{ tool: 'Read', path: skillPath, timestamp: timestamp(40) },
|
|
{ tool: 'Write', path: skillPath, timestamp: timestamp(0) },
|
|
{ tool: 'Read', path: `${skillPath}.backup`, timestamp: timestamp(0) },
|
|
]);
|
|
fs.writeFileSync(observationsPath, `${observations.map(record => JSON.stringify(record)).join('\n')}\n`);
|
|
const result = runBash(scanScript, [], { ...env, SKILL_STOCKTAKE_OBSERVATIONS: observationsPath });
|
|
assert.strictEqual(result.status, 0, result.stderr);
|
|
const output = JSON.parse(result.stdout);
|
|
for (const skillPath of observedPaths) {
|
|
const skill = output.skills.find(entry => entry.path === skillPath);
|
|
assert.ok(skill, `missing observed skill: ${skillPath}`);
|
|
assert.strictEqual(skill.use_7d, 2, skillPath);
|
|
assert.strictEqual(skill.use_30d, 3, skillPath);
|
|
}
|
|
const unobserved = output.skills.find(entry => entry.name === 'global-active');
|
|
assert.strictEqual(unobserved.use_7d, 0);
|
|
assert.strictEqual(unobserved.use_30d, 0);
|
|
});
|
|
} catch (error) {
|
|
console.log(` ✗ inventory fixture setup: ${error.message}`);
|
|
failed++;
|
|
} finally {
|
|
fs.rmSync(tempRoot, { recursive: true, force: true });
|
|
}
|
|
}
|
|
|
|
if (process.platform !== 'win32') {
|
|
const skillSource = fs.readFileSync(path.join(repoRoot, 'skills', 'skill-stocktake', 'SKILL.md'), 'utf8');
|
|
const inventorySection = skillSource.split('### Phase 1')[1].split('### Phase 2')[0];
|
|
const inventoryBlock = inventorySection.match(/```bash\n([\s\S]*?)\n```/)[1];
|
|
for (const scenario of ['changed', 'missing mtime', 'null mtime', 'matching', 'legacy matching']) {
|
|
test('documented resume reevaluates stale skills and preserves current evaluations (' + scenario + ')', () => {
|
|
const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'ecc-stocktake-resume-'));
|
|
try {
|
|
const home = path.join(tempRoot, 'home');
|
|
const skills = path.join(home, '.claude', 'skills');
|
|
const stocktake = path.join(skills, 'skill-stocktake');
|
|
fs.mkdirSync(stocktake, { recursive: true });
|
|
fs.cpSync(path.dirname(scanScript), path.join(stocktake, 'scripts'), { recursive: true });
|
|
const skillDir = path.join(skills, 'live');
|
|
writeSkill(skillDir, 'live');
|
|
const skillPath = path.join(skillDir, 'SKILL.md');
|
|
fs.utimesSync(skillPath, new Date('2025-01-01T00:00:00Z'), new Date('2025-01-01T00:00:00Z'));
|
|
const env = {
|
|
...process.env,
|
|
HOME: home,
|
|
SKILL_STOCKTAKE_GLOBAL_DIR: skills,
|
|
SKILL_STOCKTAKE_PROJECT_DIR: path.join(tempRoot, 'missing-project'),
|
|
SKILL_STOCKTAKE_OBSERVATIONS: path.join(tempRoot, 'missing-observations'),
|
|
};
|
|
const runInventory = () => spawnSync('bash', ['-c', inventoryBlock], {
|
|
cwd: tempRoot, env, encoding: 'utf8', timeout: 30000,
|
|
});
|
|
const initial = runInventory();
|
|
assert.strictEqual(initial.status, 0, initial.stderr);
|
|
const scanned = JSON.parse(initial.stdout).skills[0];
|
|
const entry = {
|
|
path: scanned.path, verdict: 'Keep', reason: 'Preserve the reviewed content',
|
|
...(scenario === 'missing mtime' ? {} : { mtime: scenario === 'null mtime' ? null : scanned.mtime }),
|
|
};
|
|
const resultsPath = path.join(stocktake, 'results.json');
|
|
fs.writeFileSync(resultsPath, JSON.stringify({
|
|
mode: 'full',
|
|
skills: { [scenario === 'legacy matching' ? 'live' : scanned.path]: entry },
|
|
batch_progress: { total: 1, evaluated: 1, status: 'in_progress' },
|
|
}));
|
|
if (scenario === 'changed') {
|
|
fs.appendFileSync(skillPath, '\nContent changed after its evaluation.\n');
|
|
fs.utimesSync(skillPath, new Date('2025-01-02T00:00:00Z'), new Date('2025-01-02T00:00:00Z'));
|
|
}
|
|
const resumed = runInventory();
|
|
assert.strictEqual(resumed.status, 0, resumed.stderr);
|
|
const output = JSON.parse(fs.readFileSync(resultsPath, 'utf8'));
|
|
const preserved = scenario === 'matching' || scenario === 'legacy matching';
|
|
assert.deepStrictEqual(output.skills, preserved ? { [scanned.path]: entry } : {});
|
|
assert.deepStrictEqual(output.batch_progress, {
|
|
total: 1, evaluated: preserved ? 1 : 0, status: 'in_progress',
|
|
});
|
|
} finally {
|
|
fs.rmSync(tempRoot, { recursive: true, force: true });
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
console.log(`\nPassed: ${passed}`);
|
|
console.log(`Failed: ${failed}`);
|
|
process.exit(failed > 0 ? 1 : 0);
|