Skip to content

armgit / ECC

Public Imported from GitHub
0

The agent harness performance optimization system. Skills, instincts, memory, security, and research-first development for Claude Code, Codex, Opencode, Cursor and beyond.

test: cover install lifecycle edge paths

Affaan Mustafab40de37ccb5c
diff --git a/tests/lib/install-lifecycle.test.js b/tests/lib/install-lifecycle.test.js
index e1c0368e5..3bd259486 100644
--- a/tests/lib/install-lifecycle.test.js
+++ b/tests/lib/install-lifecycle.test.js
@@ -10,6 +10,7 @@ const path = require('path');
const {
buildDoctorReport,
discoverInstalledStates,
+ normalizeTargets,
repairInstalledStates,
uninstallInstalledStates,
} = require('../../scripts/lib/install-lifecycle');
@@ -52,12 +53,79 @@ function writeState(filePath, options) {
return state;
}
+function createCursorStateOptions(projectRoot, overrides = {}) {
+ const targetRoot = overrides.targetRoot || path.join(projectRoot, '.cursor');
+ const installStatePath = overrides.installStatePath || path.join(targetRoot, 'ecc-install-state.json');
+
+ return {
+ adapter: { id: 'cursor-project', target: 'cursor', kind: 'project' },
+ targetRoot,
+ installStatePath,
+ request: {
+ profile: null,
+ modules: [],
+ includeComponents: [],
+ excludeComponents: [],
+ legacyLanguages: ['typescript'],
+ legacyMode: true,
+ ...(overrides.request || {}),
+ },
+ resolution: {
+ selectedModules: ['legacy-cursor-install'],
+ skippedModules: [],
+ ...(overrides.resolution || {}),
+ },
+ operations: overrides.operations || [],
+ source: {
+ repoVersion: CURRENT_PACKAGE_VERSION,
+ repoCommit: 'abc123',
+ manifestVersion: CURRENT_MANIFEST_VERSION,
+ ...(overrides.source || {}),
+ },
+ };
+}
+
+function writeCursorState(projectRoot, overrides = {}) {
+ const options = createCursorStateOptions(projectRoot, overrides);
+ writeState(options.installStatePath, options);
+ return {
+ targetRoot: options.targetRoot,
+ installStatePath: options.installStatePath,
+ state: options,
+ };
+}
+
+function managedOperation(kind, destinationPath, overrides = {}) {
+ return {
+ kind,
+ moduleId: 'test-module',
+ sourceRelativePath: 'rules/common/coding-style.md',
+ destinationPath,
+ strategy: kind,
+ ownership: 'managed',
+ scaffoldOnly: false,
+ ...overrides,
+ };
+}
+
function runTests() {
console.log('\n=== Testing install-lifecycle.js ===\n');
let passed = 0;
let failed = 0;
+ if (test('normalizes default targets and dedupes adapter aliases', () => {
+ const defaultTargets = normalizeTargets();
+
+ assert.ok(defaultTargets.includes('claude'));
+ assert.ok(defaultTargets.includes('cursor'));
+ assert.ok(defaultTargets.includes('codex'));
+ assert.deepStrictEqual(
+ normalizeTargets(['cursor-project', 'cursor', 'claude-home', 'claude']),
+ ['cursor', 'claude']
+ );
+ })) passed++; else failed++;
+
if (test('discovers installed states for multiple targets in the current context', () => {
const homeDir = createTempDir('install-lifecycle-home-');
const projectRoot = createTempDir('install-lifecycle-project-');
@@ -127,6 +195,42 @@ function runTests() {
}
})) passed++; else failed++;
+ if (test('discovers missing and invalid install-state records', () => {
+ const homeDir = createTempDir('install-lifecycle-home-');
+ const projectRoot = createTempDir('install-lifecycle-project-');
+
+ try {
+ let records = discoverInstalledStates({
+ homeDir,
+ projectRoot,
+ targets: ['cursor'],
+ });
+
+ assert.strictEqual(records.length, 1);
+ assert.strictEqual(records[0].exists, false);
+ assert.strictEqual(records[0].state, null);
+ assert.strictEqual(records[0].error, null);
+
+ const targetRoot = path.join(projectRoot, '.cursor');
+ const statePath = path.join(targetRoot, 'ecc-install-state.json');
+ fs.mkdirSync(targetRoot, { recursive: true });
+ fs.writeFileSync(statePath, '{not-json', 'utf8');
+
+ records = discoverInstalledStates({
+ homeDir,
+ projectRoot,
+ targets: ['cursor'],
+ });
+
+ assert.strictEqual(records[0].exists, true);
+ assert.strictEqual(records[0].state, null);
+ assert.ok(records[0].error.includes('Failed to read install-state'));
+ } finally {
+ cleanup(homeDir);
+ cleanup(projectRoot);
+ }
+ })) passed++; else failed++;
+
if (test('doctor reports missing managed files as an error', () => {
const homeDir = createTempDir('install-lifecycle-home-');
const projectRoot = createTempDir('install-lifecycle-project-');
@@ -184,6 +288,189 @@ function runTests() {
}
})) passed++; else failed++;
+ if (test('doctor reports target mismatches, missing sources, unverified operations, and version drift', () => {
+ const homeDir = createTempDir('install-lifecycle-home-');
+ const projectRoot = createTempDir('install-lifecycle-project-');
+
+ try {
+ const actualTargetRoot = path.join(projectRoot, '.cursor');
+ const actualStatePath = path.join(actualTargetRoot, 'ecc-install-state.json');
+ const recordedTargetRoot = path.join(projectRoot, '.old-cursor');
+ const recordedStatePath = path.join(recordedTargetRoot, 'state.json');
+ const copyDestination = path.join(actualTargetRoot, 'rules', 'missing-source.md');
+ const customDestination = path.join(actualTargetRoot, 'custom.txt');
+
+ fs.mkdirSync(path.dirname(copyDestination), { recursive: true });
+ fs.writeFileSync(copyDestination, 'managed copy\n');
+ fs.writeFileSync(customDestination, 'custom\n');
+
+ writeState(actualStatePath, createCursorStateOptions(projectRoot, {
+ targetRoot: recordedTargetRoot,
+ installStatePath: recordedStatePath,
+ request: {
+ profile: 'missing-profile',
+ legacyLanguages: [],
+ legacyMode: false,
+ },
+ resolution: {
+ selectedModules: [],
+ skippedModules: [],
+ },
+ source: {
+ repoVersion: '0.0.1',
+ manifestVersion: CURRENT_MANIFEST_VERSION + 100,
+ },
+ operations: [
+ managedOperation('copy-file', copyDestination, {
+ sourceRelativePath: 'missing/source.md',
+ strategy: 'copy-file',
+ }),
+ managedOperation('custom-kind', customDestination),
+ ],
+ }));
+
+ const report = buildDoctorReport({
+ repoRoot: REPO_ROOT,
+ homeDir,
+ projectRoot,
+ targets: ['cursor'],
+ });
+ const codes = report.results[0].issues.map(issue => issue.code);
+
+ assert.strictEqual(report.results[0].status, 'error');
+ assert.ok(codes.includes('missing-target-root'));
+ assert.ok(codes.includes('target-root-mismatch'));
+ assert.ok(codes.includes('install-state-path-mismatch'));
+ assert.ok(codes.includes('missing-source-files'));
+ assert.ok(codes.includes('unverified-managed-operations'));
+ assert.ok(codes.includes('manifest-version-mismatch'));
+ assert.ok(codes.includes('repo-version-mismatch'));
+ assert.ok(codes.includes('resolution-unavailable'));
+ assert.strictEqual(report.summary.checkedCount, 1);
+ assert.ok(report.summary.errorCount >= 3);
+ assert.ok(report.summary.warningCount >= 4);
+ } finally {
+ cleanup(homeDir);
+ cleanup(projectRoot);
+ }
+ })) passed++; else failed++;
+
+ if (test('doctor verifies render-template and merge-json operations by content', () => {
+ const homeDir = createTempDir('install-lifecycle-home-');
+ const projectRoot = createTempDir('install-lifecycle-project-');
+
+ try {
+ const targetRoot = path.join(projectRoot, '.cursor');
+ const templatePath = path.join(targetRoot, 'generated.txt');
+ const jsonPath = path.join(targetRoot, 'settings.json');
+ fs.mkdirSync(targetRoot, { recursive: true });
+ fs.writeFileSync(templatePath, 'generated\n');
+ fs.writeFileSync(jsonPath, JSON.stringify({
+ keep: true,
+ nested: {
+ managed: true,
+ extra: true,
+ },
+ }, null, 2));
+
+ writeCursorState(projectRoot, {
+ operations: [
+ managedOperation('render-template', templatePath, {
+ renderedContent: 'generated\n',
+ }),
+ managedOperation('merge-json', jsonPath, {
+ mergePayload: {
+ nested: {
+ managed: true,
+ },
+ },
+ }),
+ ],
+ });
+
+ const report = buildDoctorReport({
+ repoRoot: REPO_ROOT,
+ homeDir,
+ projectRoot,
+ targets: ['cursor'],
+ });
+
+ assert.strictEqual(report.results[0].status, 'ok');
+ assert.strictEqual(report.results[0].issues.length, 0);
+ } finally {
+ cleanup(homeDir);
+ cleanup(projectRoot);
+ }
+ })) passed++; else failed++;
+
+ if (test('doctor classifies remove, unverified template/json, and invalid JSON operation health', () => {
+ const homeDir = createTempDir('install-lifecycle-home-');
+ const projectRoot = createTempDir('install-lifecycle-project-');
+
+ try {
+ const targetRoot = path.join(projectRoot, '.cursor');
+ const templatePath = path.join(targetRoot, 'template.txt');
+ const missingPayloadJsonPath = path.join(targetRoot, 'missing-payload.json');
+ const invalidJsonPath = path.join(targetRoot, 'invalid.json');
+ const removedPath = path.join(targetRoot, 'already-removed.txt');
+ fs.mkdirSync(targetRoot, { recursive: true });
+ fs.writeFileSync(templatePath, 'generated\n');
+ fs.writeFileSync(missingPayloadJsonPath, '{"managed":true}\n');
+ fs.writeFileSync(invalidJsonPath, '{not-json', 'utf8');
+
+ writeCursorState(projectRoot, {
+ operations: [
+ managedOperation('remove', removedPath),
+ managedOperation('render-template', templatePath),
+ managedOperation('merge-json', missingPayloadJsonPath),
+ managedOperation('merge-json', invalidJsonPath, {
+ mergePayload: { managed: true },
+ }),
+ ],
+ });
+
+ const report = buildDoctorReport({
+ repoRoot: REPO_ROOT,
+ homeDir,
+ projectRoot,
+ targets: ['cursor'],
+ });
+ const codes = report.results[0].issues.map(issue => issue.code);
+
+ assert.strictEqual(report.results[0].status, 'warning');
+ assert.ok(codes.includes('unverified-managed-operations'));
+ assert.ok(codes.includes('drifted-managed-files'));
+ assert.ok(!report.results[0].issues.some(issue => issue.code === 'missing-managed-files'));
+ } finally {
+ cleanup(homeDir);
+ cleanup(projectRoot);
+ }
+ })) passed++; else failed++;
+
+ if (test('doctor reports invalid install-state files as errors', () => {
+ const homeDir = createTempDir('install-lifecycle-home-');
+ const projectRoot = createTempDir('install-lifecycle-project-');
+
+ try {
+ const statePath = path.join(projectRoot, '.cursor', 'ecc-install-state.json');
+ fs.mkdirSync(path.dirname(statePath), { recursive: true });
+ fs.writeFileSync(statePath, '{"schemaVersion":"wrong"}\n');
+
+ const report = buildDoctorReport({
+ repoRoot: REPO_ROOT,
+ homeDir,
+ projectRoot,
+ targets: ['cursor'],
+ });
+
+ assert.strictEqual(report.results[0].status, 'error');
+ assert.ok(report.results[0].issues.some(issue => issue.code === 'invalid-install-state'));
+ } finally {
+ cleanup(homeDir);
+ cleanup(projectRoot);
+ }
+ })) passed++; else failed++;
+
if (test('doctor reports a healthy legacy install when managed files are present', () => {
const homeDir = createTempDir('install-lifecycle-home-');
const projectRoot = createTempDir('install-lifecycle-project-');
@@ -244,6 +531,201 @@ function runTests() {
}
})) passed++; else failed++;
+ if (test('repair dry-run reports planned copy repairs without writing files', () => {
+ const homeDir = createTempDir('install-lifecycle-home-');
+ const projectRoot = createTempDir('install-lifecycle-project-');
+
+ try {
+ const targetRoot = path.join(projectRoot, '.cursor');
+ const destinationPath = path.join(targetRoot, 'rules', 'coding-style.md');
+ writeCursorState(projectRoot, {
+ operations: [
+ managedOperation('copy-file', destinationPath, {
+ sourceRelativePath: 'rules/common/coding-style.md',
+ strategy: 'copy-file',
+ }),
+ ],
+ });
+
+ const result = repairInstalledStates({
+ repoRoot: REPO_ROOT,
+ homeDir,
+ projectRoot,
+ targets: ['cursor'],
+ dryRun: true,
+ });
+
+ assert.strictEqual(result.dryRun, true);
+ assert.strictEqual(result.results[0].status, 'planned');
+ assert.deepStrictEqual(result.results[0].plannedRepairs, [destinationPath]);
+ assert.ok(!fs.existsSync(destinationPath));
+ } finally {
+ cleanup(homeDir);
+ cleanup(projectRoot);
+ }
+ })) 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-');
+
+ try {
+ const targetRoot = path.join(projectRoot, '.cursor');
+ const destinationPath = path.join(targetRoot, 'rules', 'coding-style.md');
+ const sourcePath = path.join(REPO_ROOT, 'rules', 'common', 'coding-style.md');
+ writeCursorState(projectRoot, {
+ operations: [
+ managedOperation('copy-file', destinationPath, {
+ sourceRelativePath: 'rules/common/coding-style.md',
+ strategy: 'copy-file',
+ }),
+ ],
+ });
+
+ const result = repairInstalledStates({
+ repoRoot: REPO_ROOT,
+ homeDir,
+ projectRoot,
+ targets: ['cursor'],
+ });
+
+ assert.strictEqual(result.results[0].status, 'repaired');
+ assert.ok(fs.readFileSync(destinationPath).equals(fs.readFileSync(sourcePath)));
+ } finally {
+ cleanup(homeDir);
+ cleanup(projectRoot);
+ }
+ })) passed++; else failed++;
+
+ if (test('repair reports invalid states, missing sources, unsupported operations, and no-op refreshes', () => {
+ const homeDir = createTempDir('install-lifecycle-home-');
+ const invalidProjectRoot = createTempDir('install-lifecycle-invalid-');
+ const missingSourceProjectRoot = createTempDir('install-lifecycle-missing-source-');
+ const unsupportedProjectRoot = createTempDir('install-lifecycle-unsupported-');
+ const okProjectRoot = createTempDir('install-lifecycle-ok-');
+
+ try {
+ const invalidStatePath = path.join(invalidProjectRoot, '.cursor', 'ecc-install-state.json');
+ fs.mkdirSync(path.dirname(invalidStatePath), { recursive: true });
+ fs.writeFileSync(invalidStatePath, '{"schemaVersion":"wrong"}\n');
+
+ let result = repairInstalledStates({
+ repoRoot: REPO_ROOT,
+ homeDir,
+ projectRoot: invalidProjectRoot,
+ targets: ['cursor'],
+ });
+ assert.strictEqual(result.results[0].status, 'error');
+ assert.ok(result.results[0].error.includes('Invalid install-state'));
+
+ const missingDestination = path.join(missingSourceProjectRoot, '.cursor', 'rules', 'missing.md');
+ fs.mkdirSync(path.dirname(missingDestination), { recursive: true });
+ fs.writeFileSync(missingDestination, 'managed\n');
+ writeCursorState(missingSourceProjectRoot, {
+ operations: [
+ managedOperation('copy-file', missingDestination, {
+ sourceRelativePath: 'missing/source.md',
+ strategy: 'copy-file',
+ }),
+ ],
+ });
+ result = repairInstalledStates({
+ repoRoot: REPO_ROOT,
+ homeDir,
+ projectRoot: missingSourceProjectRoot,
+ targets: ['cursor'],
+ });
+ assert.strictEqual(result.results[0].status, 'error');
+ assert.ok(result.results[0].error.includes('Missing source file(s)'));
+
+ const unsupportedDestination = path.join(unsupportedProjectRoot, '.cursor', 'custom.txt');
+ writeCursorState(unsupportedProjectRoot, {
+ operations: [
+ managedOperation('custom-kind', unsupportedDestination),
+ ],
+ });
+ result = repairInstalledStates({
+ repoRoot: REPO_ROOT,
+ homeDir,
+ projectRoot: unsupportedProjectRoot,
+ targets: ['cursor'],
+ });
+ assert.strictEqual(result.results[0].status, 'error');
+ assert.ok(result.results[0].error.includes('Unsupported repair operation kind'));
+
+ writeCursorState(okProjectRoot, { operations: [] });
+ result = repairInstalledStates({
+ repoRoot: REPO_ROOT,
+ homeDir,
+ projectRoot: okProjectRoot,
+ targets: ['cursor'],
+ });
+ assert.strictEqual(result.results[0].status, 'ok');
+ assert.strictEqual(result.results[0].stateRefreshed, true);
+ assert.strictEqual(result.summary.errorCount, 0);
+ } finally {
+ cleanup(homeDir);
+ cleanup(invalidProjectRoot);
+ cleanup(missingSourceProjectRoot);
+ cleanup(unsupportedProjectRoot);
+ cleanup(okProjectRoot);
+ }
+ })) passed++; else failed++;
+
+ if (test('repair dry-run reports ok when no managed operations need changes', () => {
+ const homeDir = createTempDir('install-lifecycle-home-');
+ const projectRoot = createTempDir('install-lifecycle-project-');
+
+ try {
+ writeCursorState(projectRoot, { operations: [] });
+
+ const result = repairInstalledStates({
+ repoRoot: REPO_ROOT,
+ homeDir,
+ projectRoot,
+ targets: ['cursor'],
+ dryRun: true,
+ });
+
+ assert.strictEqual(result.results[0].status, 'ok');
+ assert.strictEqual(result.results[0].stateRefreshed, true);
+ assert.deepStrictEqual(result.results[0].plannedRepairs, []);
+ } finally {
+ cleanup(homeDir);
+ cleanup(projectRoot);
+ }
+ })) passed++; else failed++;
+
+ if (test('repair surfaces missing source errors from execution when destination is absent', () => {
+ const homeDir = createTempDir('install-lifecycle-home-');
+ const projectRoot = createTempDir('install-lifecycle-project-');
+
+ try {
+ const destinationPath = path.join(projectRoot, '.cursor', 'rules', 'missing.md');
+ writeCursorState(projectRoot, {
+ operations: [
+ managedOperation('copy-file', destinationPath, {
+ sourceRelativePath: 'missing/source.md',
+ strategy: 'copy-file',
+ }),
+ ],
+ });
+
+ const result = repairInstalledStates({
+ repoRoot: REPO_ROOT,
+ homeDir,
+ projectRoot,
+ targets: ['cursor'],
+ });
+
+ assert.strictEqual(result.results[0].status, 'error');
+ assert.ok(result.results[0].error.includes('Missing source file for repair'));
+ } finally {
+ cleanup(homeDir);
+ cleanup(projectRoot);
+ }
+ })) passed++; else failed++;
+
if (test('doctor reports drifted managed files as a warning', () => {
const homeDir = createTempDir('install-lifecycle-home-');
const projectRoot = createTempDir('install-lifecycle-project-');
@@ -731,6 +1213,394 @@ function runTests() {
}
})) passed++; else failed++;
+ if (test('uninstall dry-run reports deduped managed removals without deleting files', () => {
+ const homeDir = createTempDir('install-lifecycle-home-');
+ const projectRoot = createTempDir('install-lifecycle-project-');
+
+ try {
+ const targetRoot = path.join(projectRoot, '.cursor');
+ const destinationPath = path.join(targetRoot, 'rules', 'coding-style.md');
+ fs.mkdirSync(path.dirname(destinationPath), { recursive: true });
+ fs.writeFileSync(destinationPath, 'managed\n');
+ const { installStatePath } = writeCursorState(projectRoot, {
+ operations: [
+ managedOperation('copy-file', destinationPath, { strategy: 'copy-file' }),
+ managedOperation('copy-file', destinationPath, { strategy: 'copy-file' }),
+ ],
+ });
+
+ const result = uninstallInstalledStates({
+ homeDir,
+ projectRoot,
+ targets: ['cursor'],
+ dryRun: true,
+ });
+
+ assert.strictEqual(result.dryRun, true);
+ assert.strictEqual(result.results[0].status, 'planned');
+ assert.deepStrictEqual(result.results[0].plannedRemovals, [
+ destinationPath,
+ installStatePath,
+ ]);
+ assert.ok(fs.existsSync(destinationPath));
+ assert.ok(fs.existsSync(installStatePath));
+ } finally {
+ cleanup(homeDir);
+ cleanup(projectRoot);
+ }
+ })) passed++; else failed++;
+
+ if (test('uninstall reports invalid install states as errors', () => {
+ const homeDir = createTempDir('install-lifecycle-home-');
+ const projectRoot = createTempDir('install-lifecycle-project-');
+
+ try {
+ const statePath = path.join(projectRoot, '.cursor', 'ecc-install-state.json');
+ fs.mkdirSync(path.dirname(statePath), { recursive: true });
+ fs.writeFileSync(statePath, '{not-json', 'utf8');
+
+ const result = uninstallInstalledStates({
+ homeDir,
+ projectRoot,
+ targets: ['cursor'],
+ });
+
+ assert.strictEqual(result.results[0].status, 'error');
+ assert.ok(result.results[0].error.includes('Failed to read install-state'));
+ assert.strictEqual(result.summary.errorCount, 1);
+ } finally {
+ cleanup(homeDir);
+ cleanup(projectRoot);
+ }
+ })) passed++; else failed++;
+
+ if (test('uninstall removes copied files and cleans empty parent directories', () => {
+ const homeDir = createTempDir('install-lifecycle-home-');
+ const projectRoot = createTempDir('install-lifecycle-project-');
+
+ try {
+ const targetRoot = path.join(projectRoot, '.cursor');
+ const destinationPath = path.join(targetRoot, 'rules', 'nested', 'managed.md');
+ fs.mkdirSync(path.dirname(destinationPath), { recursive: true });
+ fs.writeFileSync(destinationPath, 'managed\n');
+ writeCursorState(projectRoot, {
+ operations: [
+ managedOperation('copy-file', destinationPath, { strategy: 'copy-file' }),
+ ],
+ });
+
+ const result = uninstallInstalledStates({
+ homeDir,
+ projectRoot,
+ targets: ['cursor'],
+ });
+
+ assert.strictEqual(result.results[0].status, 'uninstalled');
+ assert.ok(result.results[0].removedPaths.includes(destinationPath));
+ assert.ok(!fs.existsSync(destinationPath));
+ assert.ok(!fs.existsSync(path.dirname(destinationPath)));
+ assert.ok(fs.existsSync(targetRoot));
+ } finally {
+ cleanup(homeDir);
+ cleanup(projectRoot);
+ }
+ })) passed++; else failed++;
+
+ if (test('uninstall handles merge-json subset removal and full-file deletion', () => {
+ const homeDir = createTempDir('install-lifecycle-home-');
+ const partialProjectRoot = createTempDir('install-lifecycle-partial-');
+ const fullProjectRoot = createTempDir('install-lifecycle-full-');
+
+ try {
+ let targetRoot = path.join(partialProjectRoot, '.cursor');
+ let destinationPath = path.join(targetRoot, 'settings.json');
+ fs.mkdirSync(targetRoot, { recursive: true });
+ fs.writeFileSync(destinationPath, JSON.stringify({
+ keep: true,
+ managed: true,
+ nested: {
+ keep: true,
+ remove: true,
+ },
+ list: ['a', 'b'],
+ }, null, 2));
+ writeCursorState(partialProjectRoot, {
+ operations: [
+ managedOperation('merge-json', destinationPath, {
+ mergePayload: {
+ managed: true,
+ nested: { remove: true },
+ list: ['a', 'b'],
+ },
+ }),
+ ],
+ });
+
+ let result = uninstallInstalledStates({
+ homeDir,
+ projectRoot: partialProjectRoot,
+ targets: ['cursor'],
+ });
+ assert.strictEqual(result.results[0].status, 'uninstalled');
+ assert.deepStrictEqual(JSON.parse(fs.readFileSync(destinationPath, 'utf8')), {
+ keep: true,
+ nested: {
+ keep: true,
+ },
+ });
+
+ targetRoot = path.join(fullProjectRoot, '.cursor');
+ destinationPath = path.join(targetRoot, 'settings.json');
+ fs.mkdirSync(targetRoot, { recursive: true });
+ fs.writeFileSync(destinationPath, JSON.stringify({ managed: true }, null, 2));
+ writeCursorState(fullProjectRoot, {
+ operations: [
+ managedOperation('merge-json', destinationPath, {
+ mergePayload: { managed: true },
+ }),
+ ],
+ });
+
+ result = uninstallInstalledStates({
+ homeDir,
+ projectRoot: fullProjectRoot,
+ targets: ['cursor'],
+ });
+ assert.strictEqual(result.results[0].status, 'uninstalled');
+ assert.ok(!fs.existsSync(destinationPath));
+ } finally {
+ cleanup(homeDir);
+ cleanup(partialProjectRoot);
+ cleanup(fullProjectRoot);
+ }
+ })) passed++; else failed++;
+
+ if (test('uninstall handles merge-json edge shapes and absent destinations', () => {
+ const homeDir = createTempDir('install-lifecycle-home-');
+ const projects = [
+ createTempDir('install-lifecycle-current-primitive-'),
+ createTempDir('install-lifecycle-missing-key-'),
+ createTempDir('install-lifecycle-nested-delete-'),
+ createTempDir('install-lifecycle-array-root-'),
+ createTempDir('install-lifecycle-primitive-root-'),
+ createTempDir('install-lifecycle-absent-dest-'),
+ createTempDir('install-lifecycle-previous-json-'),
+ ];
+
+ try {
+ const cases = [
+ {
+ projectRoot: projects[0],
+ initial: '"plain"',
+ payload: { managed: true },
+ expected: 'plain',
+ },
+ {
+ projectRoot: projects[1],
+ initial: { keep: true },
+ payload: { missing: true },
+ expected: { keep: true },
+ },
+ {
+ projectRoot: projects[2],
+ initial: { keep: true, nested: { remove: true } },
+ payload: { nested: { remove: true } },
+ expected: { keep: true },
+ },
+ {
+ projectRoot: projects[3],
+ initial: ['a', 'b'],
+ payload: ['a', 'b'],
+ removed: true,
+ },
+ {
+ projectRoot: projects[4],
+ initial: true,
+ payload: true,
+ removed: true,
+ },
+ {
+ projectRoot: projects[5],
+ payload: { managed: true },
+ absent: true,
+ },
+ {
+ projectRoot: projects[6],
+ initial: { generated: true },
+ payload: { generated: true },
+ previousJson: { restored: true },
+ expected: { restored: true },
+ },
+ ];
+
+ for (const testCase of cases) {
+ const targetRoot = path.join(testCase.projectRoot, '.cursor');
+ const destinationPath = path.join(targetRoot, 'settings.json');
+ fs.mkdirSync(targetRoot, { recursive: true });
+ if (!testCase.absent) {
+ fs.writeFileSync(
+ destinationPath,
+ typeof testCase.initial === 'string'
+ ? `${testCase.initial}\n`
+ : JSON.stringify(testCase.initial, null, 2)
+ );
+ }
+ writeCursorState(testCase.projectRoot, {
+ operations: [
+ managedOperation('merge-json', destinationPath, {
+ mergePayload: testCase.payload,
+ previousJson: testCase.previousJson,
+ }),
+ ],
+ });
+
+ const result = uninstallInstalledStates({
+ homeDir,
+ projectRoot: testCase.projectRoot,
+ targets: ['cursor'],
+ });
+
+ assert.strictEqual(result.results[0].status, 'uninstalled');
+ if (testCase.removed || testCase.absent) {
+ assert.ok(!fs.existsSync(destinationPath));
+ } else {
+ assert.deepStrictEqual(JSON.parse(fs.readFileSync(destinationPath, 'utf8')), testCase.expected);
+ }
+ }
+ } finally {
+ cleanup(homeDir);
+ for (const projectRoot of projects) {
+ cleanup(projectRoot);
+ }
+ }
+ })) passed++; else failed++;
+
+ if (test('uninstall removes generated render-template files and no-backup remove operations are no-ops', () => {
+ const homeDir = createTempDir('install-lifecycle-home-');
+ const projectRoot = createTempDir('install-lifecycle-project-');
+
+ try {
+ const targetRoot = path.join(projectRoot, '.cursor');
+ const templatePath = path.join(targetRoot, 'generated', 'plugin.json');
+ const removedPath = path.join(targetRoot, 'already-removed.txt');
+ fs.mkdirSync(path.dirname(templatePath), { recursive: true });
+ fs.writeFileSync(templatePath, '{"generated":true}\n');
+
+ writeCursorState(projectRoot, {
+ operations: [
+ managedOperation('render-template', templatePath, {
+ renderedContent: '{"generated":true}\n',
+ }),
+ managedOperation('remove', removedPath),
+ ],
+ });
+
+ const result = uninstallInstalledStates({
+ homeDir,
+ projectRoot,
+ targets: ['cursor'],
+ });
+
+ assert.strictEqual(result.results[0].status, 'uninstalled');
+ assert.ok(result.results[0].removedPaths.includes(templatePath));
+ assert.ok(!fs.existsSync(templatePath));
+ assert.ok(!fs.existsSync(path.dirname(templatePath)));
+ } finally {
+ cleanup(homeDir);
+ cleanup(projectRoot);
+ }
+ })) passed++; else failed++;
+
+ if (test('uninstall restores previous JSON snapshots for template and remove operations', () => {
+ const homeDir = createTempDir('install-lifecycle-home-');
+ const projectRoot = createTempDir('install-lifecycle-project-');
+
+ try {
+ const targetRoot = path.join(projectRoot, '.cursor');
+ const templatePath = path.join(targetRoot, 'plugin.json');
+ const removedPath = path.join(targetRoot, 'legacy.json');
+ fs.mkdirSync(targetRoot, { recursive: true });
+ fs.writeFileSync(templatePath, '{"generated":true}\n');
+
+ writeCursorState(projectRoot, {
+ operations: [
+ managedOperation('render-template', templatePath, {
+ previousJson: { existing: true },
+ renderedContent: '{"generated":true}\n',
+ }),
+ managedOperation('remove', removedPath, {
+ previousJson: { restored: true },
+ }),
+ ],
+ });
+
+ const result = uninstallInstalledStates({
+ homeDir,
+ projectRoot,
+ targets: ['cursor'],
+ });
+
+ assert.strictEqual(result.results[0].status, 'uninstalled');
+ assert.deepStrictEqual(JSON.parse(fs.readFileSync(templatePath, 'utf8')), {
+ existing: true,
+ });
+ assert.deepStrictEqual(JSON.parse(fs.readFileSync(removedPath, 'utf8')), {
+ restored: true,
+ });
+ } finally {
+ cleanup(homeDir);
+ cleanup(projectRoot);
+ }
+ })) passed++; else failed++;
+
+ if (test('uninstall reports unsupported operations and missing merge payloads as errors', () => {
+ const homeDir = createTempDir('install-lifecycle-home-');
+ const unsupportedProjectRoot = createTempDir('install-lifecycle-unsupported-');
+ const missingPayloadProjectRoot = createTempDir('install-lifecycle-missing-payload-');
+
+ try {
+ let targetRoot = path.join(unsupportedProjectRoot, '.cursor');
+ let destinationPath = path.join(targetRoot, 'custom.txt');
+ fs.mkdirSync(targetRoot, { recursive: true });
+ fs.writeFileSync(destinationPath, 'custom\n');
+ writeCursorState(unsupportedProjectRoot, {
+ operations: [
+ managedOperation('custom-kind', destinationPath),
+ ],
+ });
+
+ let result = uninstallInstalledStates({
+ homeDir,
+ projectRoot: unsupportedProjectRoot,
+ targets: ['cursor'],
+ });
+ assert.strictEqual(result.results[0].status, 'error');
+ assert.ok(result.results[0].error.includes('Unsupported uninstall operation kind'));
+
+ targetRoot = path.join(missingPayloadProjectRoot, '.cursor');
+ destinationPath = path.join(targetRoot, 'settings.json');
+ fs.mkdirSync(targetRoot, { recursive: true });
+ fs.writeFileSync(destinationPath, '{"managed":true}\n');
+ writeCursorState(missingPayloadProjectRoot, {
+ operations: [
+ managedOperation('merge-json', destinationPath),
+ ],
+ });
+
+ result = uninstallInstalledStates({
+ homeDir,
+ projectRoot: missingPayloadProjectRoot,
+ targets: ['cursor'],
+ });
+ assert.strictEqual(result.results[0].status, 'error');
+ assert.ok(result.results[0].error.includes('Missing merge payload for uninstall'));
+ } finally {
+ cleanup(homeDir);
+ cleanup(unsupportedProjectRoot);
+ cleanup(missingPayloadProjectRoot);
+ }
+ })) passed++; else failed++;
+
console.log(`\nResults: Passed: ${passed}, Failed: ${failed}`);
process.exit(failed > 0 ? 1 : 0);
}