Kjell Tore Guttormsen
7e94910566
CLAUDE.md token estimates counted block-level <!-- --> HTML comments toward always-loaded tokens, but CC strips them before injection (preserved only inside code fences, per code.claude.com/docs/en/memory). Fix: new stripInjectedHtmlComments + effectiveMemoryBytes in active-config-reader; the CML cascade (walkClaudeMdCascade) and token-hotspots now size CLAUDE.md from effective (stripped) bytes, while raw byte figures stay honest. Block-level only — inline comments retained (conservative, verified scope). Suite 1329/0 (+13). Frozen v5.0.0 snapshots untouched (no fixture has <!--), no re-seed. Dogfood ~/.claude CLAUDE.md ~3386->3301 tok (~85 tok discount, matches worklist prediction).
1160 lines
50 KiB
JavaScript
1160 lines
50 KiB
JavaScript
import { describe, it, before, after, beforeEach, afterEach } from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import { join, dirname, resolve } from 'node:path';
|
|
import { mkdir, writeFile, rm, readFile } from 'node:fs/promises';
|
|
import { tmpdir } from 'node:os';
|
|
import {
|
|
estimateTokens,
|
|
stripInjectedHtmlComments,
|
|
effectiveMemoryBytes,
|
|
detectGitRoot,
|
|
walkClaudeMdCascade,
|
|
readClaudeJsonProjectSlice,
|
|
enumeratePlugins,
|
|
enumerateSkills,
|
|
readActiveHooks,
|
|
readActiveMcpServers,
|
|
readActiveConfig,
|
|
deriveLoadPattern,
|
|
enumerateRules,
|
|
enumerateAgents,
|
|
enumerateOutputStyles,
|
|
} from '../../scanners/lib/active-config-reader.mjs';
|
|
|
|
function uniqueDir(suffix) {
|
|
return join(tmpdir(), `config-audit-acr-${suffix}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`);
|
|
}
|
|
|
|
/**
|
|
* Build a rich-repo fixture under `root`.
|
|
* Layout mirrors feature plan §8 — git-repo, CLAUDE.md cascade, settings layers,
|
|
* .mcp.json, fake-home with plugins + .claude.json.
|
|
*/
|
|
async function buildRichRepo(root) {
|
|
const fakeHome = join(root, 'fake-home');
|
|
// Repo marker
|
|
await mkdir(join(root, '.git'), { recursive: true });
|
|
await writeFile(join(root, '.git', 'HEAD'), 'ref: refs/heads/main\n');
|
|
|
|
// Project CLAUDE.md with @import
|
|
await mkdir(join(root, 'docs'), { recursive: true });
|
|
await writeFile(
|
|
join(root, 'CLAUDE.md'),
|
|
'# Project Instructions\n\n@docs/conv.md\n\nBuild with care.\n',
|
|
);
|
|
await writeFile(join(root, 'docs', 'conv.md'), '# Conventions\n\nUse conventional commits.\n');
|
|
|
|
// Settings cascade
|
|
await mkdir(join(root, '.claude', 'rules'), { recursive: true });
|
|
await writeFile(
|
|
join(root, '.claude', 'settings.json'),
|
|
JSON.stringify({
|
|
permissions: { allow: ['Read', 'Write'] },
|
|
hooks: {
|
|
PreToolUse: [
|
|
{ matcher: 'Bash', hooks: [{ type: 'command', command: 'check.sh' }] },
|
|
],
|
|
},
|
|
}, null, 2),
|
|
);
|
|
await writeFile(
|
|
join(root, '.claude', 'settings.local.json'),
|
|
JSON.stringify({ env: { DEBUG: 'true' } }, null, 2),
|
|
);
|
|
await writeFile(join(root, '.claude', 'rules', 'team.md'), '# Team Rule\n');
|
|
|
|
// Project .mcp.json
|
|
await writeFile(
|
|
join(root, '.mcp.json'),
|
|
JSON.stringify({
|
|
mcpServers: {
|
|
alpha: { command: 'npx', args: ['alpha-server'] },
|
|
beta: { command: 'npx', args: ['beta-server'] },
|
|
},
|
|
}, null, 2),
|
|
);
|
|
|
|
// Fake HOME — user CLAUDE.md, settings, plugins, .claude.json
|
|
await mkdir(join(fakeHome, '.claude'), { recursive: true });
|
|
await writeFile(
|
|
join(fakeHome, '.claude', 'CLAUDE.md'),
|
|
'# User Instructions\n\nBe terse.\n',
|
|
);
|
|
await writeFile(
|
|
join(fakeHome, '.claude', 'settings.json'),
|
|
JSON.stringify({
|
|
hooks: {
|
|
Stop: [{ hooks: [{ type: 'command', command: 'reminder.sh' }] }],
|
|
},
|
|
}, null, 2),
|
|
);
|
|
|
|
// Plugin: demo plugin with 1 command, 1 skill, 1 hook
|
|
const pluginRoot = join(
|
|
fakeHome, '.claude', 'plugins', 'marketplaces', 'mp', 'plugins', 'demo',
|
|
);
|
|
await mkdir(join(pluginRoot, '.claude-plugin'), { recursive: true });
|
|
await writeFile(
|
|
join(pluginRoot, '.claude-plugin', 'plugin.json'),
|
|
JSON.stringify({ name: 'demo', description: 'test plugin', version: '0.1.0' }, null, 2),
|
|
);
|
|
await mkdir(join(pluginRoot, 'commands'), { recursive: true });
|
|
await writeFile(
|
|
join(pluginRoot, 'commands', 'foo.md'),
|
|
'---\nname: demo:foo\ndescription: foo\nmodel: sonnet\n---\n\nFoo command.\n',
|
|
);
|
|
await mkdir(join(pluginRoot, 'skills', 'bar'), { recursive: true });
|
|
await writeFile(
|
|
join(pluginRoot, 'skills', 'bar', 'SKILL.md'),
|
|
'---\nname: bar\ndescription: bar skill\n---\n\nBar skill body.\n',
|
|
);
|
|
await mkdir(join(pluginRoot, 'hooks'), { recursive: true });
|
|
await writeFile(
|
|
join(pluginRoot, 'hooks', 'hooks.json'),
|
|
JSON.stringify({
|
|
hooks: {
|
|
PostToolUse: [{ hooks: [{ type: 'command', command: 'demo-hook.sh' }] }],
|
|
},
|
|
}, null, 2),
|
|
);
|
|
|
|
// ~/.claude.json with projects slice matching the repo root
|
|
await writeFile(
|
|
join(fakeHome, '.claude.json'),
|
|
JSON.stringify({
|
|
projects: {
|
|
[root]: {
|
|
mcpServers: {
|
|
gamma: { command: 'gamma-server' },
|
|
},
|
|
disabledMcpjsonServers: ['beta'],
|
|
},
|
|
},
|
|
}, null, 2),
|
|
);
|
|
|
|
return { root, fakeHome, pluginRoot };
|
|
}
|
|
|
|
// ─────────────────────────────────────────────────────────────────────────
|
|
// estimateTokens
|
|
// ─────────────────────────────────────────────────────────────────────────
|
|
|
|
describe('estimateTokens', () => {
|
|
it('markdown: 4 chars per token, rounded up', () => {
|
|
assert.equal(estimateTokens(400, 'markdown'), 100);
|
|
assert.equal(estimateTokens(401, 'markdown'), 101);
|
|
assert.equal(estimateTokens(0, 'markdown'), 0);
|
|
});
|
|
|
|
it('json: 3.5 chars per token, rounded up', () => {
|
|
assert.equal(estimateTokens(350, 'json'), 100);
|
|
assert.equal(estimateTokens(100, 'json'), 29);
|
|
});
|
|
|
|
it('frontmatter: caps at 600 bytes / 150 tokens', () => {
|
|
assert.equal(estimateTokens(100, 'frontmatter'), 25);
|
|
assert.equal(estimateTokens(600, 'frontmatter'), 150);
|
|
assert.equal(estimateTokens(10_000, 'frontmatter'), 150);
|
|
});
|
|
|
|
it('item: flat 15 regardless of bytes', () => {
|
|
assert.equal(estimateTokens(0, 'item'), 15);
|
|
assert.equal(estimateTokens(9999, 'item'), 15);
|
|
});
|
|
|
|
it('defaults to markdown when kind omitted', () => {
|
|
assert.equal(estimateTokens(400), 100);
|
|
});
|
|
|
|
it('handles invalid bytes gracefully', () => {
|
|
assert.equal(estimateTokens(-1, 'markdown'), 0);
|
|
assert.equal(estimateTokens(NaN, 'markdown'), 0);
|
|
});
|
|
|
|
// v5 F2: differentiated MCP estimate
|
|
it('mcp: 0 bytes → at least 500 (base overhead floor)', () => {
|
|
assert.ok(estimateTokens(0, 'mcp') >= 500,
|
|
`expected >= 500, got ${estimateTokens(0, 'mcp')}`);
|
|
});
|
|
|
|
it('mcp: with toolCount: 10 → at least 2000', () => {
|
|
assert.ok(estimateTokens(0, 'mcp', { toolCount: 10 }) >= 2000,
|
|
`expected >= 2000, got ${estimateTokens(0, 'mcp', { toolCount: 10 })}`);
|
|
});
|
|
|
|
it('mcp: ratio mcp/item ≥ 30 for 10-tool server', () => {
|
|
const mcp = estimateTokens(0, 'mcp', { toolCount: 10 });
|
|
const item = estimateTokens(0, 'item');
|
|
assert.ok(mcp / item >= 30,
|
|
`expected ratio >= 30, got mcp=${mcp} item=${item} ratio=${mcp / item}`);
|
|
});
|
|
|
|
it('mcp: with bytes uses json-rate floor', () => {
|
|
// 700 bytes JSON ≈ 200 tokens, but mcp keeps 500 floor
|
|
assert.equal(estimateTokens(700, 'mcp'), 500);
|
|
// 3500 bytes JSON = 1000 tokens, exceeds floor
|
|
assert.equal(estimateTokens(3500, 'mcp'), 1000);
|
|
});
|
|
});
|
|
|
|
// ─────────────────────────────────────────────────────────────────────────
|
|
// stripInjectedHtmlComments / effectiveMemoryBytes (M-BUG-6)
|
|
// Claude Code strips block-level HTML comments from a CLAUDE.md/memory file
|
|
// before injecting it into context (code.claude.com/docs/en/memory), preserving
|
|
// them only inside fenced code blocks. A byte-accurate token estimate must
|
|
// discount them. Inline comments (text on the same line) are conservatively
|
|
// retained — only block-level stripping is verified behavior.
|
|
// ─────────────────────────────────────────────────────────────────────────
|
|
|
|
describe('stripInjectedHtmlComments (M-BUG-6)', () => {
|
|
it('strips a single-line block-level comment outside code fences', () => {
|
|
const src = '# Title\n\n<!-- maintainer note: regenerate weekly -->\n\nBody text.\n';
|
|
const out = stripInjectedHtmlComments(src);
|
|
assert.ok(!out.includes('maintainer note'), 'comment text should be removed');
|
|
assert.ok(out.includes('# Title') && out.includes('Body text.'), 'surrounding content preserved');
|
|
});
|
|
|
|
it('strips a multi-line block comment outside fences', () => {
|
|
const src = 'A\n<!--\nline one\nline two\n-->\nB\n';
|
|
const out = stripInjectedHtmlComments(src);
|
|
assert.ok(!out.includes('line one') && !out.includes('line two'), 'all comment lines removed');
|
|
assert.ok(out.includes('A') && out.includes('B'), 'surrounding content preserved');
|
|
});
|
|
|
|
it('preserves an HTML comment inside a ``` fenced code block', () => {
|
|
const src = '# Title\n\n```html\n<!-- kept: this is example code -->\n```\n';
|
|
const out = stripInjectedHtmlComments(src);
|
|
assert.ok(out.includes('kept: this is example code'), 'fenced comment must be preserved (CC keeps it)');
|
|
});
|
|
|
|
it('preserves an HTML comment inside a ~~~ fenced code block', () => {
|
|
const src = '~~~\n<!-- kept tilde -->\n~~~\n';
|
|
const out = stripInjectedHtmlComments(src);
|
|
assert.ok(out.includes('kept tilde'), 'tilde-fenced comment must be preserved');
|
|
});
|
|
|
|
it('keeps inline comments (only block-level stripping is verified)', () => {
|
|
// Text on the same line as the comment → conservatively retained; the
|
|
// verified CC behavior covers block-level comments only (Verifiseringsplikt).
|
|
const src = 'Visible <!-- hidden --> tail\n';
|
|
assert.equal(stripInjectedHtmlComments(src), src);
|
|
});
|
|
|
|
it('returns content unchanged when there are no comments', () => {
|
|
const src = '# Plain\n\nNo comments here.\n';
|
|
assert.equal(stripInjectedHtmlComments(src), src);
|
|
});
|
|
|
|
it('handles empty and non-string input', () => {
|
|
assert.equal(stripInjectedHtmlComments(''), '');
|
|
assert.equal(stripInjectedHtmlComments(undefined), '');
|
|
assert.equal(stripInjectedHtmlComments(null), '');
|
|
});
|
|
});
|
|
|
|
describe('effectiveMemoryBytes (M-BUG-6)', () => {
|
|
it('discounts out-of-fence block comments from the byte count', () => {
|
|
const src = '# Title\n\n<!-- a fairly long maintainer note that costs real bytes -->\n\nBody.\n';
|
|
const raw = Buffer.byteLength(src, 'utf8');
|
|
const eff = effectiveMemoryBytes(src);
|
|
assert.ok(eff < raw, `effective (${eff}) should be below raw (${raw})`);
|
|
});
|
|
|
|
it('counts comments inside fences (CC keeps them)', () => {
|
|
const src = '```\n<!-- kept -->\n```\n';
|
|
assert.equal(effectiveMemoryBytes(src), Buffer.byteLength(src, 'utf8'));
|
|
});
|
|
|
|
it('equals raw bytes when no comments are present', () => {
|
|
const src = '# Plain markdown\n\nbody\n';
|
|
assert.equal(effectiveMemoryBytes(src), Buffer.byteLength(src, 'utf8'));
|
|
});
|
|
|
|
it('returns 0 for non-string input', () => {
|
|
assert.equal(effectiveMemoryBytes(undefined), 0);
|
|
assert.equal(effectiveMemoryBytes(null), 0);
|
|
});
|
|
});
|
|
|
|
// ─────────────────────────────────────────────────────────────────────────
|
|
// detectGitRoot
|
|
// ─────────────────────────────────────────────────────────────────────────
|
|
|
|
describe('detectGitRoot', () => {
|
|
let root;
|
|
before(async () => {
|
|
root = uniqueDir('git');
|
|
await mkdir(join(root, '.git'), { recursive: true });
|
|
await mkdir(join(root, 'src', 'deep'), { recursive: true });
|
|
await writeFile(join(root, '.git', 'HEAD'), '\n');
|
|
});
|
|
after(async () => { await rm(root, { recursive: true, force: true }); });
|
|
|
|
it('finds .git in start dir', async () => {
|
|
const result = await detectGitRoot(root);
|
|
assert.equal(result, resolve(root));
|
|
});
|
|
|
|
it('walks up to find .git', async () => {
|
|
const result = await detectGitRoot(join(root, 'src', 'deep'));
|
|
assert.equal(result, resolve(root));
|
|
});
|
|
|
|
it('returns null when no .git in chain', async () => {
|
|
const noGit = uniqueDir('nogit');
|
|
await mkdir(noGit, { recursive: true });
|
|
try {
|
|
const result = await detectGitRoot(noGit);
|
|
// Could resolve to outer repo (the plugin repo) if tmpdir happens to be nested.
|
|
// Accept null OR a path that is NOT noGit itself.
|
|
if (result !== null) {
|
|
assert.notEqual(result, resolve(noGit));
|
|
}
|
|
} finally {
|
|
await rm(noGit, { recursive: true, force: true });
|
|
}
|
|
});
|
|
});
|
|
|
|
// ─────────────────────────────────────────────────────────────────────────
|
|
// walkClaudeMdCascade
|
|
// ─────────────────────────────────────────────────────────────────────────
|
|
|
|
describe('walkClaudeMdCascade', () => {
|
|
let fixture;
|
|
let originalHome;
|
|
|
|
beforeEach(async () => {
|
|
fixture = await buildRichRepo(uniqueDir('cascade'));
|
|
originalHome = process.env.HOME;
|
|
process.env.HOME = fixture.fakeHome;
|
|
});
|
|
|
|
afterEach(async () => {
|
|
process.env.HOME = originalHome;
|
|
await rm(fixture.root, { recursive: true, force: true });
|
|
});
|
|
|
|
it('returns files in load order (user first, then project, then imports)', async () => {
|
|
const result = await walkClaudeMdCascade(fixture.root);
|
|
const scopes = result.files.map(f => f.scope);
|
|
assert.ok(scopes.includes('user'), 'expected user scope');
|
|
assert.ok(scopes.includes('project'), 'expected project scope');
|
|
assert.ok(scopes.includes('import'), 'expected import scope');
|
|
|
|
// user CLAUDE.md should come before project CLAUDE.md
|
|
const userIdx = result.files.findIndex(f => f.scope === 'user');
|
|
const projIdx = result.files.findIndex(f => f.scope === 'project');
|
|
assert.ok(userIdx < projIdx, 'user scope must come before project');
|
|
});
|
|
|
|
it('resolves @imports and marks them with parent', async () => {
|
|
const result = await walkClaudeMdCascade(fixture.root);
|
|
const imp = result.files.find(f => f.path.endsWith('docs/conv.md'));
|
|
assert.ok(imp, 'import should be discovered');
|
|
assert.equal(imp.scope, 'import');
|
|
assert.ok(imp.parent && imp.parent.endsWith('CLAUDE.md'));
|
|
});
|
|
|
|
it('counts bytes and lines', async () => {
|
|
const result = await walkClaudeMdCascade(fixture.root);
|
|
assert.ok(result.totalBytes > 0);
|
|
assert.ok(result.totalLines > 0);
|
|
for (const f of result.files) {
|
|
assert.ok(f.bytes > 0);
|
|
assert.ok(f.lines > 0);
|
|
}
|
|
});
|
|
|
|
it('computes estimatedTokens via markdown heuristic', async () => {
|
|
const result = await walkClaudeMdCascade(fixture.root);
|
|
assert.equal(result.estimatedTokens, Math.ceil(result.totalBytes / 4));
|
|
});
|
|
|
|
it('discounts block-level HTML comments from estimatedTokens (M-BUG-6)', async () => {
|
|
// CC strips block-level HTML comments before injection, so a CLAUDE.md
|
|
// padded with a maintainer-note comment must estimate FEWER tokens than its
|
|
// raw byte size would imply — totalBytes stays the honest on-disk figure.
|
|
const comment = `<!-- ${'maintainer note '.repeat(40)} -->`;
|
|
await writeFile(
|
|
join(fixture.root, 'CLAUDE.md'),
|
|
`# Project Instructions\n\n${comment}\n\nBuild with care.\n`,
|
|
);
|
|
const result = await walkClaudeMdCascade(fixture.root);
|
|
assert.ok(
|
|
result.estimatedTokens < Math.ceil(result.totalBytes / 4),
|
|
`expected discounted tokens (${result.estimatedTokens}) below raw heuristic ` +
|
|
`(${Math.ceil(result.totalBytes / 4)})`,
|
|
);
|
|
});
|
|
|
|
it('handles missing user CLAUDE.md gracefully', async () => {
|
|
// Remove user CLAUDE.md
|
|
await rm(join(fixture.fakeHome, '.claude', 'CLAUDE.md'));
|
|
const result = await walkClaudeMdCascade(fixture.root);
|
|
const userFiles = result.files.filter(f => f.scope === 'user');
|
|
assert.equal(userFiles.length, 0);
|
|
});
|
|
});
|
|
|
|
// ─────────────────────────────────────────────────────────────────────────
|
|
// readClaudeJsonProjectSlice
|
|
// ─────────────────────────────────────────────────────────────────────────
|
|
|
|
describe('readClaudeJsonProjectSlice', () => {
|
|
let fixture;
|
|
let originalHome;
|
|
|
|
beforeEach(async () => {
|
|
fixture = await buildRichRepo(uniqueDir('slice'));
|
|
originalHome = process.env.HOME;
|
|
process.env.HOME = fixture.fakeHome;
|
|
});
|
|
afterEach(async () => {
|
|
process.env.HOME = originalHome;
|
|
await rm(fixture.root, { recursive: true, force: true });
|
|
});
|
|
|
|
it('finds exact-match project key', async () => {
|
|
const slice = await readClaudeJsonProjectSlice(fixture.root);
|
|
assert.equal(slice.projectKey, fixture.root);
|
|
assert.deepEqual(slice.disabledMcpjsonServers, ['beta']);
|
|
assert.ok('gamma' in slice.mcpServers);
|
|
});
|
|
|
|
it('returns empty slice when no .claude.json exists', async () => {
|
|
await rm(join(fixture.fakeHome, '.claude.json'));
|
|
const slice = await readClaudeJsonProjectSlice(fixture.root);
|
|
assert.equal(slice.projectKey, null);
|
|
assert.deepEqual(slice.mcpServers, {});
|
|
});
|
|
|
|
it('longest-prefix match: deeper key wins over shallower', async () => {
|
|
// Rewrite .claude.json with two keys — ancestor and the repo
|
|
const parent = dirname(fixture.root);
|
|
const content = JSON.stringify({
|
|
projects: {
|
|
[parent]: { mcpServers: { shallow: { command: 'shallow' } } },
|
|
[fixture.root]: { mcpServers: { deep: { command: 'deep' } } },
|
|
},
|
|
}, null, 2);
|
|
await writeFile(join(fixture.fakeHome, '.claude.json'), content);
|
|
|
|
const slice = await readClaudeJsonProjectSlice(fixture.root);
|
|
assert.equal(slice.projectKey, fixture.root);
|
|
assert.ok('deep' in slice.mcpServers);
|
|
assert.ok(!('shallow' in slice.mcpServers));
|
|
});
|
|
|
|
it('ancestor prefix matches when target is a subdir of a key', async () => {
|
|
const parent = dirname(fixture.root);
|
|
await writeFile(
|
|
join(fixture.fakeHome, '.claude.json'),
|
|
JSON.stringify({ projects: { [parent]: { mcpServers: { anc: {} } } } }, null, 2),
|
|
);
|
|
const slice = await readClaudeJsonProjectSlice(fixture.root);
|
|
assert.equal(slice.projectKey, parent);
|
|
});
|
|
|
|
it('returns null projectKey when no key matches', async () => {
|
|
await writeFile(
|
|
join(fixture.fakeHome, '.claude.json'),
|
|
JSON.stringify({ projects: { '/some/other/path': {} } }, null, 2),
|
|
);
|
|
const slice = await readClaudeJsonProjectSlice(fixture.root);
|
|
assert.equal(slice.projectKey, null);
|
|
});
|
|
});
|
|
|
|
// ─────────────────────────────────────────────────────────────────────────
|
|
// enumeratePlugins
|
|
// ─────────────────────────────────────────────────────────────────────────
|
|
|
|
describe('enumeratePlugins', () => {
|
|
let fixture;
|
|
let originalHome;
|
|
|
|
beforeEach(async () => {
|
|
fixture = await buildRichRepo(uniqueDir('plugins'));
|
|
originalHome = process.env.HOME;
|
|
process.env.HOME = fixture.fakeHome;
|
|
});
|
|
afterEach(async () => {
|
|
process.env.HOME = originalHome;
|
|
await rm(fixture.root, { recursive: true, force: true });
|
|
});
|
|
|
|
it('discovers plugin and reads plugin.json version', async () => {
|
|
const plugins = await enumeratePlugins();
|
|
assert.ok(plugins.length >= 1);
|
|
const demo = plugins.find(p => p.name === 'demo');
|
|
assert.ok(demo, 'demo plugin should be discovered');
|
|
assert.equal(demo.version, '0.1.0');
|
|
});
|
|
|
|
it('counts commands, skills, hooks', async () => {
|
|
const plugins = await enumeratePlugins();
|
|
const demo = plugins.find(p => p.name === 'demo');
|
|
assert.equal(demo.commands, 1);
|
|
assert.equal(demo.skills, 1);
|
|
assert.equal(demo.hooks, 1);
|
|
});
|
|
|
|
it('returns empty array when HOME has no plugins', async () => {
|
|
process.env.HOME = uniqueDir('empty');
|
|
await mkdir(process.env.HOME, { recursive: true });
|
|
try {
|
|
const plugins = await enumeratePlugins();
|
|
assert.deepEqual(plugins, []);
|
|
} finally {
|
|
await rm(process.env.HOME, { recursive: true, force: true });
|
|
}
|
|
});
|
|
});
|
|
|
|
// ─────────────────────────────────────────────────────────────────────────
|
|
// enumeratePlugins — enabledPlugins + installed_plugins.json (M-BUG-1)
|
|
// ─────────────────────────────────────────────────────────────────────────
|
|
|
|
/**
|
|
* Build a fake HOME that mirrors a real machine: an installed_plugins.json
|
|
* manifest (polyrepo plugins live under plugins/cache, monorepo ones under
|
|
* plugins/marketplaces) + an enabledPlugins toggle map in settings.json.
|
|
*
|
|
* The enumerator must inject ONLY enabled plugins, resolving each to its ACTIVE
|
|
* installPath — including cache/ paths the marketplaces walk never sees — and
|
|
* must NOT count disabled plugins, plugins absent from enabledPlugins, or
|
|
* marketplaces plugins absent from the manifest entirely (the real M-BUG-1).
|
|
*/
|
|
async function buildManifestHome(home) {
|
|
const cacheRoot = join(home, '.claude', 'plugins', 'cache', 'mp');
|
|
const mpRoot = join(home, '.claude', 'plugins', 'marketplaces', 'mp', 'plugins');
|
|
|
|
async function makePlugin(root, name, version) {
|
|
await mkdir(join(root, '.claude-plugin'), { recursive: true });
|
|
await writeFile(
|
|
join(root, '.claude-plugin', 'plugin.json'),
|
|
JSON.stringify({ name, description: name, version }, null, 2),
|
|
);
|
|
await mkdir(join(root, 'agents'), { recursive: true });
|
|
await writeFile(
|
|
join(root, 'agents', `${name}-agent.md`),
|
|
`---\nname: ${name}-agent\ndescription: ${name} agent\n---\nbody\n`,
|
|
);
|
|
}
|
|
|
|
const enabledCachePath = join(cacheRoot, 'enabled-cache', '1.0.0');
|
|
const disabledCachePath = join(cacheRoot, 'disabled-cache', '1.0.0');
|
|
const enabledMpPath = join(mpRoot, 'enabled-mp');
|
|
const notToggledMpPath = join(mpRoot, 'not-toggled-mp');
|
|
const ghostMpPath = join(mpRoot, 'ghost-mp'); // on disk, absent from manifest
|
|
|
|
await makePlugin(enabledCachePath, 'enabled-cache', '1.0.0');
|
|
await makePlugin(disabledCachePath, 'disabled-cache', '1.0.0');
|
|
await makePlugin(enabledMpPath, 'enabled-mp', '0.1.0');
|
|
await makePlugin(notToggledMpPath, 'not-toggled-mp', '0.1.0');
|
|
await makePlugin(ghostMpPath, 'ghost-mp', '0.1.0');
|
|
|
|
await mkdir(join(home, '.claude', 'plugins'), { recursive: true });
|
|
await writeFile(
|
|
join(home, '.claude', 'plugins', 'installed_plugins.json'),
|
|
JSON.stringify({
|
|
version: 2,
|
|
plugins: {
|
|
'enabled-cache@mp': [{ scope: 'user', installPath: enabledCachePath, version: '1.0.0' }],
|
|
'disabled-cache@mp': [{ scope: 'user', installPath: disabledCachePath, version: '1.0.0' }],
|
|
'enabled-mp@mp': [{ scope: 'user', installPath: enabledMpPath, version: '0.1.0' }],
|
|
'not-toggled-mp@mp': [{ scope: 'user', installPath: notToggledMpPath, version: '0.1.0' }],
|
|
// ghost-mp deliberately absent from the manifest
|
|
},
|
|
}, null, 2),
|
|
);
|
|
|
|
await writeFile(
|
|
join(home, '.claude', 'settings.json'),
|
|
JSON.stringify({
|
|
enabledPlugins: {
|
|
'enabled-cache@mp': true,
|
|
'disabled-cache@mp': false,
|
|
'enabled-mp@mp': true,
|
|
// not-toggled-mp@mp deliberately absent (treated as not enabled)
|
|
},
|
|
}, null, 2),
|
|
);
|
|
}
|
|
|
|
describe('enumeratePlugins — enabledPlugins + installed_plugins.json (M-BUG-1)', () => {
|
|
let home, originalHome;
|
|
beforeEach(async () => {
|
|
home = uniqueDir('manifest-home');
|
|
await mkdir(home, { recursive: true });
|
|
originalHome = process.env.HOME;
|
|
process.env.HOME = home;
|
|
});
|
|
afterEach(async () => {
|
|
process.env.HOME = originalHome;
|
|
await rm(home, { recursive: true, force: true });
|
|
});
|
|
|
|
it('injects only ENABLED plugins (honors enabledPlugins toggle)', async () => {
|
|
await buildManifestHome(home);
|
|
const names = (await enumeratePlugins()).map(p => p.name).sort();
|
|
assert.deepEqual(names, ['enabled-cache', 'enabled-mp']);
|
|
});
|
|
|
|
it('excludes disabled, not-toggled, and manifest-absent (ghost) plugins', async () => {
|
|
await buildManifestHome(home);
|
|
const names = (await enumeratePlugins()).map(p => p.name);
|
|
assert.ok(!names.includes('disabled-cache'), 'disabled plugin must not be injected');
|
|
assert.ok(!names.includes('not-toggled-mp'), 'plugin absent from enabledPlugins must not be injected');
|
|
assert.ok(!names.includes('ghost-mp'), 'marketplaces plugin absent from manifest must not be injected');
|
|
});
|
|
|
|
it('resolves an enabled plugin from plugins/cache (polyrepo installPath)', async () => {
|
|
await buildManifestHome(home);
|
|
const cached = (await enumeratePlugins()).find(p => p.name === 'enabled-cache');
|
|
assert.ok(cached, 'cache-installed enabled plugin must be discovered');
|
|
assert.ok(cached.path.includes(join('plugins', 'cache')), `expected a cache/ path, got ${cached.path}`);
|
|
assert.equal(cached.agents, 1);
|
|
});
|
|
|
|
it('falls back to the marketplaces walk when installed_plugins.json is absent', async () => {
|
|
// No manifest → cannot tell enabled from installed → discover all on disk.
|
|
const legacyRoot = join(home, '.claude', 'plugins', 'marketplaces', 'mp', 'plugins', 'legacy');
|
|
await mkdir(join(legacyRoot, '.claude-plugin'), { recursive: true });
|
|
await writeFile(
|
|
join(legacyRoot, '.claude-plugin', 'plugin.json'),
|
|
JSON.stringify({ name: 'legacy', version: '9.9.9' }, null, 2),
|
|
);
|
|
const plugins = await enumeratePlugins();
|
|
assert.ok(plugins.find(p => p.name === 'legacy'), 'legacy marketplaces plugin discovered via fallback');
|
|
});
|
|
});
|
|
|
|
// ─────────────────────────────────────────────────────────────────────────
|
|
// enumerateSkills
|
|
// ─────────────────────────────────────────────────────────────────────────
|
|
|
|
describe('enumerateSkills', () => {
|
|
let fixture;
|
|
let originalHome;
|
|
|
|
beforeEach(async () => {
|
|
fixture = await buildRichRepo(uniqueDir('skills'));
|
|
originalHome = process.env.HOME;
|
|
process.env.HOME = fixture.fakeHome;
|
|
});
|
|
afterEach(async () => {
|
|
process.env.HOME = originalHome;
|
|
await rm(fixture.root, { recursive: true, force: true });
|
|
});
|
|
|
|
it('finds plugin skills', async () => {
|
|
const plugins = await enumeratePlugins();
|
|
const skills = await enumerateSkills(plugins);
|
|
const bar = skills.find(s => s.name === 'bar');
|
|
assert.ok(bar, 'plugin skill should be discovered');
|
|
assert.equal(bar.source, 'plugin');
|
|
assert.equal(bar.pluginName, 'demo');
|
|
});
|
|
|
|
it('finds user skills', async () => {
|
|
// Add a user skill
|
|
await mkdir(join(fixture.fakeHome, '.claude', 'skills', 'userskill'), { recursive: true });
|
|
await writeFile(
|
|
join(fixture.fakeHome, '.claude', 'skills', 'userskill', 'SKILL.md'),
|
|
'# user skill\n',
|
|
);
|
|
const skills = await enumerateSkills([]);
|
|
const userSkill = skills.find(s => s.name === 'userskill');
|
|
assert.ok(userSkill, 'user skill should be discovered');
|
|
assert.equal(userSkill.source, 'user');
|
|
});
|
|
});
|
|
|
|
// ─────────────────────────────────────────────────────────────────────────
|
|
// readActiveHooks
|
|
// ─────────────────────────────────────────────────────────────────────────
|
|
|
|
describe('readActiveHooks', () => {
|
|
let fixture;
|
|
let originalHome;
|
|
|
|
beforeEach(async () => {
|
|
fixture = await buildRichRepo(uniqueDir('hooks'));
|
|
originalHome = process.env.HOME;
|
|
process.env.HOME = fixture.fakeHome;
|
|
});
|
|
afterEach(async () => {
|
|
process.env.HOME = originalHome;
|
|
await rm(fixture.root, { recursive: true, force: true });
|
|
});
|
|
|
|
it('merges hooks from user + project + plugin', async () => {
|
|
const plugins = await enumeratePlugins();
|
|
const hooks = await readActiveHooks(fixture.root, plugins);
|
|
const sources = new Set(hooks.map(h => h.source));
|
|
assert.ok(sources.has('user'), 'user hook present');
|
|
assert.ok(sources.has('project'), 'project hook present');
|
|
assert.ok([...sources].some(s => s.startsWith('plugin:')), 'plugin hook present');
|
|
});
|
|
|
|
it('does not dedupe across scopes', async () => {
|
|
// Add duplicate hook in user and project settings
|
|
const dupeHook = {
|
|
hooks: { PreToolUse: [{ matcher: 'Bash', hooks: [{ type: 'command', command: 'same.sh' }] }] },
|
|
};
|
|
await writeFile(join(fixture.fakeHome, '.claude', 'settings.json'), JSON.stringify(dupeHook));
|
|
await writeFile(join(fixture.root, '.claude', 'settings.json'), JSON.stringify(dupeHook));
|
|
const hooks = await readActiveHooks(fixture.root, []);
|
|
const sameCmd = hooks.filter(h => h.command === 'same.sh');
|
|
assert.equal(sameCmd.length, 2, 'should report both occurrences');
|
|
});
|
|
});
|
|
|
|
// ─────────────────────────────────────────────────────────────────────────
|
|
// readActiveMcpServers
|
|
// ─────────────────────────────────────────────────────────────────────────
|
|
|
|
describe('readActiveMcpServers', () => {
|
|
let fixture;
|
|
let originalHome;
|
|
|
|
beforeEach(async () => {
|
|
fixture = await buildRichRepo(uniqueDir('mcp'));
|
|
originalHome = process.env.HOME;
|
|
process.env.HOME = fixture.fakeHome;
|
|
});
|
|
afterEach(async () => {
|
|
process.env.HOME = originalHome;
|
|
await rm(fixture.root, { recursive: true, force: true });
|
|
});
|
|
|
|
it('merges project .mcp.json + .claude.json slice', async () => {
|
|
const servers = await readActiveMcpServers(fixture.root);
|
|
const names = servers.map(s => s.name);
|
|
assert.ok(names.includes('alpha'), 'alpha from project');
|
|
assert.ok(names.includes('beta'), 'beta from project');
|
|
assert.ok(names.includes('gamma'), 'gamma from .claude.json');
|
|
});
|
|
|
|
it('honors disabledMcpjsonServers', async () => {
|
|
const servers = await readActiveMcpServers(fixture.root);
|
|
const beta = servers.find(s => s.name === 'beta');
|
|
assert.equal(beta.enabled, false);
|
|
assert.equal(beta.disabledBy, 'disabledMcpjsonServers');
|
|
|
|
const alpha = servers.find(s => s.name === 'alpha');
|
|
assert.equal(alpha.enabled, true);
|
|
assert.equal(alpha.disabledBy, null);
|
|
});
|
|
|
|
it('estimatedTokens >= 500 for every MCP server (v5 F2)', async () => {
|
|
const servers = await readActiveMcpServers(fixture.root);
|
|
assert.ok(servers.length > 0, 'fixture should produce MCP servers');
|
|
for (const s of servers) {
|
|
assert.ok(s.estimatedTokens >= 500,
|
|
`${s.name} from ${s.source} has estimatedTokens=${s.estimatedTokens}, expected >= 500`);
|
|
}
|
|
});
|
|
});
|
|
|
|
// ─────────────────────────────────────────────────────────────────────────
|
|
// readActiveMcpServers — tool-count detection (v5 M1)
|
|
// ─────────────────────────────────────────────────────────────────────────
|
|
|
|
describe('readActiveMcpServers — tool-count detection (v5 M1)', () => {
|
|
it('detects toolCount from project node_modules/<pkg>/package.json', async () => {
|
|
const fixturePath = resolve(import.meta.dirname || dirname(new URL(import.meta.url).pathname),
|
|
'..', 'fixtures', 'mcp-tool-heavy');
|
|
const servers = await readActiveMcpServers(fixturePath);
|
|
const heavy = servers.find(s => s.name === 'heavy');
|
|
assert.ok(heavy, 'expected heavy server from fixture');
|
|
assert.equal(heavy.toolCount, 20, `expected toolCount=20, got ${heavy.toolCount}`);
|
|
assert.equal(heavy.toolCountUnknown, false);
|
|
});
|
|
|
|
it('falls back to toolCount: null + toolCountUnknown: true when manifest missing', async () => {
|
|
const fixturePath = resolve(import.meta.dirname || dirname(new URL(import.meta.url).pathname),
|
|
'..', 'fixtures', 'mcp-tool-heavy');
|
|
const servers = await readActiveMcpServers(fixturePath);
|
|
const light = servers.find(s => s.name === 'light');
|
|
assert.ok(light, 'expected light server from fixture');
|
|
assert.equal(light.toolCount, null);
|
|
assert.equal(light.toolCountUnknown, true);
|
|
});
|
|
|
|
it('detects toolCount from cache file in $HOME/.claude/config-audit/mcp-cache/', async () => {
|
|
const fakeHome = uniqueDir('mcp-cache');
|
|
const repoRoot = uniqueDir('mcp-cache-repo');
|
|
await mkdir(repoRoot, { recursive: true });
|
|
await writeFile(
|
|
join(repoRoot, '.mcp.json'),
|
|
JSON.stringify({ mcpServers: { cached: { command: 'npx', args: ['unknown-pkg'] } } }, null, 2),
|
|
);
|
|
await mkdir(join(fakeHome, '.claude', 'config-audit', 'mcp-cache'), { recursive: true });
|
|
await writeFile(
|
|
join(fakeHome, '.claude', 'config-audit', 'mcp-cache', 'cached.json'),
|
|
JSON.stringify({ tools: Array.from({ length: 12 }, (_, i) => ({ name: `t${i}` })) }, null, 2),
|
|
);
|
|
const originalHome = process.env.HOME;
|
|
process.env.HOME = fakeHome;
|
|
try {
|
|
const servers = await readActiveMcpServers(repoRoot);
|
|
const cached = servers.find(s => s.name === 'cached');
|
|
assert.ok(cached, 'expected cached server');
|
|
assert.equal(cached.toolCount, 12, `expected toolCount=12 from cache, got ${cached.toolCount}`);
|
|
assert.equal(cached.toolCountUnknown, false);
|
|
} finally {
|
|
process.env.HOME = originalHome;
|
|
await rm(fakeHome, { recursive: true, force: true });
|
|
await rm(repoRoot, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
it('toolCount drives estimateTokens (heavy > light)', async () => {
|
|
const fixturePath = resolve(import.meta.dirname || dirname(new URL(import.meta.url).pathname),
|
|
'..', 'fixtures', 'mcp-tool-heavy');
|
|
const servers = await readActiveMcpServers(fixturePath);
|
|
const heavy = servers.find(s => s.name === 'heavy');
|
|
const light = servers.find(s => s.name === 'light');
|
|
assert.ok(heavy.estimatedTokens > light.estimatedTokens,
|
|
`expected heavy (${heavy.estimatedTokens}) > light (${light.estimatedTokens})`);
|
|
});
|
|
});
|
|
|
|
// ─────────────────────────────────────────────────────────────────────────
|
|
// readActiveConfig (integration)
|
|
// ─────────────────────────────────────────────────────────────────────────
|
|
|
|
describe('readActiveConfig (integration)', () => {
|
|
let fixture;
|
|
let originalHome;
|
|
|
|
beforeEach(async () => {
|
|
fixture = await buildRichRepo(uniqueDir('full'));
|
|
originalHome = process.env.HOME;
|
|
process.env.HOME = fixture.fakeHome;
|
|
});
|
|
afterEach(async () => {
|
|
process.env.HOME = originalHome;
|
|
await rm(fixture.root, { recursive: true, force: true });
|
|
});
|
|
|
|
it('produces expected top-level shape', async () => {
|
|
const result = await readActiveConfig(fixture.root);
|
|
const keys = Object.keys(result).sort();
|
|
assert.deepEqual(keys, [
|
|
'agents', 'claudeMd', 'hooks', 'mcpServers', 'meta', 'outputStyles',
|
|
'plugins', 'rules', 'settings', 'skills', 'suggestDisables', 'totals', 'warnings',
|
|
]);
|
|
});
|
|
|
|
it('meta contains required fields', async () => {
|
|
const result = await readActiveConfig(fixture.root);
|
|
assert.equal(result.meta.tool, 'config-audit:whats-active');
|
|
assert.equal(result.meta.version, '1.0.0');
|
|
assert.ok(typeof result.meta.generatedAt === 'string');
|
|
assert.equal(result.meta.repoPath, resolve(fixture.root));
|
|
assert.equal(result.meta.gitRoot, resolve(fixture.root));
|
|
assert.equal(result.meta.projectKey, fixture.root);
|
|
assert.ok(typeof result.meta.durationMs === 'number');
|
|
});
|
|
|
|
it('settings cascade reflects all three layers', async () => {
|
|
const result = await readActiveConfig(fixture.root);
|
|
const scopes = result.settings.cascade.map(c => c.scope);
|
|
assert.deepEqual(scopes, ['user', 'project', 'local']);
|
|
const user = result.settings.cascade.find(c => c.scope === 'user');
|
|
const project = result.settings.cascade.find(c => c.scope === 'project');
|
|
assert.equal(user.exists, true);
|
|
assert.equal(project.exists, true);
|
|
});
|
|
|
|
it('totals.grandTotal equals sum of category subtotals', async () => {
|
|
const result = await readActiveConfig(fixture.root);
|
|
const t = result.totals.estimatedTokens;
|
|
assert.equal(t.grandTotal,
|
|
t.claudeMd + t.plugins + t.skills + t.mcpServers + t.hooks + t.rules + t.agents + t.outputStyles);
|
|
});
|
|
|
|
it('performance budget: durationMs < 2000', async () => {
|
|
const result = await readActiveConfig(fixture.root);
|
|
assert.ok(result.meta.durationMs < 2000,
|
|
`expected < 2000ms, got ${result.meta.durationMs}ms`);
|
|
});
|
|
|
|
it('token estimate within ±20% of hand-computed value', async () => {
|
|
const result = await readActiveConfig(fixture.root);
|
|
const expectedClaudeMd = Math.ceil(result.claudeMd.totalBytes / 4);
|
|
const low = Math.floor(expectedClaudeMd * 0.8);
|
|
const high = Math.ceil(expectedClaudeMd * 1.2);
|
|
assert.ok(
|
|
result.totals.estimatedTokens.claudeMd >= low &&
|
|
result.totals.estimatedTokens.claudeMd <= high,
|
|
`claudeMd tokens ${result.totals.estimatedTokens.claudeMd} outside [${low}, ${high}]`,
|
|
);
|
|
});
|
|
|
|
it('suggestDisables is null by default, object when flag set', async () => {
|
|
const noFlag = await readActiveConfig(fixture.root);
|
|
assert.equal(noFlag.suggestDisables, null);
|
|
|
|
const withFlag = await readActiveConfig(fixture.root, { suggestDisables: true });
|
|
assert.ok(withFlag.suggestDisables && Array.isArray(withFlag.suggestDisables.candidates));
|
|
});
|
|
|
|
it('suggestDisables flags disabled MCP servers', async () => {
|
|
const result = await readActiveConfig(fixture.root, { suggestDisables: true });
|
|
const betaCandidate = result.suggestDisables.candidates.find(
|
|
c => c.kind === 'mcp' && c.name === 'beta',
|
|
);
|
|
assert.ok(betaCandidate, 'beta should be flagged as already disabled');
|
|
assert.equal(betaCandidate.confidence, 'high');
|
|
});
|
|
|
|
it('enumerates rules/agents/outputStyles into the result and totals', async () => {
|
|
const result = await readActiveConfig(fixture.root);
|
|
// buildRichRepo ships one unscoped project rule (.claude/rules/team.md)
|
|
assert.ok(Array.isArray(result.rules) && result.rules.length >= 1);
|
|
const team = result.rules.find(r => r.name === 'team.md');
|
|
assert.ok(team, 'team.md rule should be enumerated');
|
|
assert.equal(team.loadPattern, 'always');
|
|
assert.ok(Array.isArray(result.agents));
|
|
assert.ok(Array.isArray(result.outputStyles));
|
|
assert.equal(result.totals.rules, result.rules.length);
|
|
assert.equal(result.totals.agents, result.agents.length);
|
|
assert.equal(result.totals.outputStyles, result.outputStyles.length);
|
|
});
|
|
});
|
|
|
|
// ─────────────────────────────────────────────────────────────────────────
|
|
// v5.6 Foundation — deriveLoadPattern + rule/agent/output-style enumeration
|
|
// ─────────────────────────────────────────────────────────────────────────
|
|
|
|
describe('deriveLoadPattern (v5.6)', () => {
|
|
const cases = [
|
|
['claude-md-root', {}, 'always', 'yes', 'confirmed'],
|
|
['claude-md-nested', {}, 'on-demand', 'no', 'confirmed'],
|
|
['claude-md-user', {}, 'always', 'yes', 'inferred'],
|
|
['claude-md-managed', {}, 'always', 'yes', 'inferred'],
|
|
['claude-md-import', {}, 'always', 'yes', 'inferred'],
|
|
['rule', { scoped: true }, 'on-demand', 'no', 'confirmed'],
|
|
['rule', { scoped: false }, 'always', 'yes', 'confirmed'],
|
|
['skill-listing', {}, 'always', 'n/a', 'confirmed'],
|
|
['skill-body', {}, 'on-demand', 'n/a', 'confirmed'],
|
|
['agent', {}, 'always', 'n/a', 'inferred'],
|
|
['output-style', {}, 'always', 'yes', 'confirmed'],
|
|
['hook', {}, 'external', 'n/a', 'confirmed'],
|
|
['mcp', {}, 'always', 'yes', 'inferred'],
|
|
// v5.6 B2 — kinds surfaced by the token-hotspots discovery surface.
|
|
['command', {}, 'on-demand', 'n/a', 'inferred'], // body loads on /invoke
|
|
['harness-config', {}, 'external', 'n/a', 'inferred'], // settings/manifests: not model context
|
|
];
|
|
for (const [kind, opts, loadPattern, survivesCompaction, derivationConfidence] of cases) {
|
|
const label = `${kind}${opts.scoped !== undefined ? ` (scoped=${opts.scoped})` : ''}`;
|
|
it(`${label} → ${loadPattern}/${survivesCompaction}/${derivationConfidence}`, () => {
|
|
assert.deepEqual(deriveLoadPattern(kind, opts), {
|
|
loadPattern, survivesCompaction, derivationConfidence,
|
|
});
|
|
});
|
|
}
|
|
it('falls back safely for an unknown kind', () => {
|
|
assert.deepEqual(deriveLoadPattern('nope'), {
|
|
loadPattern: 'unknown', survivesCompaction: 'n/a', derivationConfidence: 'inferred',
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('enumerateRules (v5.6)', () => {
|
|
let root, emptyHome, originalHome;
|
|
beforeEach(async () => {
|
|
root = uniqueDir('rules');
|
|
emptyHome = uniqueDir('rules-home');
|
|
await mkdir(emptyHome, { recursive: true });
|
|
originalHome = process.env.HOME;
|
|
process.env.HOME = emptyHome;
|
|
});
|
|
afterEach(async () => {
|
|
process.env.HOME = originalHome;
|
|
await rm(root, { recursive: true, force: true });
|
|
await rm(emptyHome, { recursive: true, force: true });
|
|
});
|
|
|
|
it('tags scoped vs unscoped project rules (block-sequence paths detected)', async () => {
|
|
await mkdir(join(root, '.claude', 'rules'), { recursive: true });
|
|
await writeFile(join(root, '.claude', 'rules', 'always.md'), '# Always-on rule\n');
|
|
await writeFile(
|
|
join(root, '.claude', 'rules', 'scoped.md'),
|
|
'---\npaths:\n - src/**/*.ts\n---\n# Scoped rule\n',
|
|
);
|
|
const rules = await enumerateRules(root, []);
|
|
const always = rules.find(r => r.name === 'always.md');
|
|
const scoped = rules.find(r => r.name === 'scoped.md');
|
|
assert.equal(always.scoped, false);
|
|
assert.equal(always.loadPattern, 'always');
|
|
assert.equal(always.survivesCompaction, 'yes');
|
|
assert.equal(always.source, 'project');
|
|
assert.equal(scoped.scoped, true);
|
|
assert.equal(scoped.loadPattern, 'on-demand');
|
|
assert.equal(scoped.survivesCompaction, 'no');
|
|
});
|
|
|
|
it('discovers user-level rules', async () => {
|
|
await mkdir(join(emptyHome, '.claude', 'rules'), { recursive: true });
|
|
await writeFile(join(emptyHome, '.claude', 'rules', 'user.md'), '# User rule\n');
|
|
const rules = await enumerateRules(root, []);
|
|
const user = rules.find(r => r.name === 'user.md');
|
|
assert.ok(user);
|
|
assert.equal(user.source, 'user');
|
|
});
|
|
|
|
it('returns [] when there are no rules', async () => {
|
|
await mkdir(root, { recursive: true });
|
|
assert.deepEqual(await enumerateRules(root, []), []);
|
|
});
|
|
});
|
|
|
|
describe('enumerateAgents (v5.6)', () => {
|
|
let root, emptyHome, originalHome;
|
|
beforeEach(async () => {
|
|
root = uniqueDir('agents');
|
|
emptyHome = uniqueDir('agents-home');
|
|
await mkdir(emptyHome, { recursive: true });
|
|
originalHome = process.env.HOME;
|
|
process.env.HOME = emptyHome;
|
|
});
|
|
afterEach(async () => {
|
|
process.env.HOME = originalHome;
|
|
await rm(root, { recursive: true, force: true });
|
|
await rm(emptyHome, { recursive: true, force: true });
|
|
});
|
|
|
|
it('enumerates project agents as always-loaded (inferred)', async () => {
|
|
await mkdir(join(root, '.claude', 'agents'), { recursive: true });
|
|
await writeFile(
|
|
join(root, '.claude', 'agents', 'reviewer.md'),
|
|
'---\nname: reviewer\ndescription: reviews code\n---\nbody\n',
|
|
);
|
|
const agents = await enumerateAgents(root, []);
|
|
const a = agents.find(x => x.name === 'reviewer');
|
|
assert.ok(a);
|
|
assert.equal(a.source, 'project');
|
|
assert.equal(a.loadPattern, 'always');
|
|
assert.equal(a.survivesCompaction, 'n/a');
|
|
assert.equal(a.derivationConfidence, 'inferred');
|
|
});
|
|
|
|
it('returns [] when there are no agents', async () => {
|
|
await mkdir(root, { recursive: true });
|
|
assert.deepEqual(await enumerateAgents(root, []), []);
|
|
});
|
|
|
|
// M-BUG-5: CC registers a subagent only when its frontmatter declares both
|
|
// `name` and `description` (docs: identity comes only from `name`; both are
|
|
// required). Frontmatter-less / incomplete files are registration no-ops that
|
|
// cost zero always-loaded tokens — they must NOT be counted as agents.
|
|
it('M-BUG-5: skips files with no frontmatter at all', async () => {
|
|
const dir = join(root, '.claude', 'agents');
|
|
await mkdir(dir, { recursive: true });
|
|
await writeFile(join(dir, 'reviewer.md'), '---\nname: reviewer\ndescription: reviews code\n---\nbody\n');
|
|
await writeFile(join(dir, 'not-an-agent.md'), '# Not An Agent\n\nJust a markdown doc, no frontmatter.\n');
|
|
const agents = await enumerateAgents(root, []);
|
|
assert.deepEqual(agents.map(a => a.name).sort(), ['reviewer']);
|
|
});
|
|
|
|
it('M-BUG-5: skips files missing name or description', async () => {
|
|
const dir = join(root, '.claude', 'agents');
|
|
await mkdir(dir, { recursive: true });
|
|
await writeFile(join(dir, 'reviewer.md'), '---\nname: reviewer\ndescription: reviews code\n---\nbody\n');
|
|
await writeFile(join(dir, 'name-only.md'), '---\nname: name-only\n---\nbody\n');
|
|
await writeFile(join(dir, 'desc-only.md'), '---\ndescription: has no name\n---\nbody\n');
|
|
await writeFile(join(dir, 'empty-name.md'), '---\nname:\ndescription: blank name\n---\nbody\n');
|
|
const agents = await enumerateAgents(root, []);
|
|
assert.deepEqual(agents.map(a => a.name).sort(), ['reviewer']);
|
|
});
|
|
|
|
// M-BUG-3: CC scans agents dirs recursively, so a valid agent in a subfolder
|
|
// (e.g. agents/review/security.md) is registered and must be counted.
|
|
it('M-BUG-3: recurses into agent subdirectories', async () => {
|
|
const sub = join(root, '.claude', 'agents', 'review');
|
|
await mkdir(sub, { recursive: true });
|
|
await writeFile(join(sub, 'security.md'), '---\nname: security\ndescription: security review\n---\nbody\n');
|
|
const agents = await enumerateAgents(root, []);
|
|
const a = agents.find(x => x.name === 'security');
|
|
assert.ok(a, 'agent in subdir should be counted');
|
|
assert.equal(a.source, 'project');
|
|
});
|
|
});
|
|
|
|
// M-BUG-4: when repoPath === $HOME (the `manifest --global` self-scan), the
|
|
// project agents dir resolves to the SAME path as the user agents dir. The
|
|
// shared configDirs helper must count it once (as user scope), not twice.
|
|
describe('enumerateAgents — HOME self-scan dedup (M-BUG-4)', () => {
|
|
let home, originalHome;
|
|
beforeEach(async () => {
|
|
home = uniqueDir('agents-home-selfscan');
|
|
await mkdir(join(home, '.claude', 'agents'), { recursive: true });
|
|
originalHome = process.env.HOME;
|
|
process.env.HOME = home;
|
|
});
|
|
afterEach(async () => {
|
|
process.env.HOME = originalHome;
|
|
await rm(home, { recursive: true, force: true });
|
|
});
|
|
|
|
it('does not double-count user agents when repoPath === HOME', async () => {
|
|
await writeFile(
|
|
join(home, '.claude', 'agents', 'solo.md'),
|
|
'---\nname: solo\ndescription: only one of me\n---\nbody\n',
|
|
);
|
|
const agents = await enumerateAgents(home, []);
|
|
const solos = agents.filter(a => a.name === 'solo');
|
|
assert.equal(solos.length, 1, 'agent at HOME must be counted once, not twice');
|
|
assert.equal(solos[0].source, 'user', 'HOME self-scan agents are user scope');
|
|
});
|
|
});
|
|
|
|
describe('enumerateOutputStyles (v5.6)', () => {
|
|
let root, emptyHome, originalHome;
|
|
beforeEach(async () => {
|
|
root = uniqueDir('ost');
|
|
emptyHome = uniqueDir('ost-home');
|
|
await mkdir(emptyHome, { recursive: true });
|
|
originalHome = process.env.HOME;
|
|
process.env.HOME = emptyHome;
|
|
});
|
|
afterEach(async () => {
|
|
process.env.HOME = originalHome;
|
|
await rm(root, { recursive: true, force: true });
|
|
await rm(emptyHome, { recursive: true, force: true });
|
|
});
|
|
|
|
it('enumerates project + user output styles as always/yes', async () => {
|
|
await mkdir(join(root, '.claude', 'output-styles'), { recursive: true });
|
|
await writeFile(
|
|
join(root, '.claude', 'output-styles', 'custom.md'),
|
|
'---\nname: Custom\ndescription: x\n---\nStyle instructions.\n',
|
|
);
|
|
await mkdir(join(emptyHome, '.claude', 'output-styles'), { recursive: true });
|
|
await writeFile(
|
|
join(emptyHome, '.claude', 'output-styles', 'user-style.md'),
|
|
'---\nname: UserStyle\n---\nMore.\n',
|
|
);
|
|
const styles = await enumerateOutputStyles(root, []);
|
|
const proj = styles.find(s => s.name === 'custom');
|
|
const user = styles.find(s => s.name === 'user-style');
|
|
assert.ok(proj && user);
|
|
assert.equal(proj.source, 'project');
|
|
assert.equal(proj.loadPattern, 'always');
|
|
assert.equal(proj.survivesCompaction, 'yes');
|
|
assert.equal(proj.derivationConfidence, 'confirmed');
|
|
assert.equal(user.source, 'user');
|
|
});
|
|
|
|
it('returns [] when there are no output styles', async () => {
|
|
await mkdir(root, { recursive: true });
|
|
assert.deepEqual(await enumerateOutputStyles(root, []), []);
|
|
});
|
|
});
|