aios-core 4.2.14 → 4.3.0

package/packages/installer/tests/unit/ide-sync-integration/ide-sync-integration.test.js

@@ -0,0 +1,230 @@
+'use strict';
+
+/**
+ * IDE Sync Integration Tests (Story INS-4.5)
+ *
+ * Verifies that the installer calls commandSync and commandValidate
+ * via the adapter pattern (save cwd, chdir, finally restore).
+ */
+
+const path = require('path');
+
+// Mock the ide-sync module before requiring wizard
+const mockCommandSync = jest.fn();
+const mockCommandValidate = jest.fn();
+
+jest.mock('../../../../../.aios-core/infrastructure/scripts/ide-sync/index', () => ({
+  commandSync: mockCommandSync,
+  commandValidate: mockCommandValidate,
+}));
+
+// We need to verify that the wizard source code has the correct integration
+const fs = require('fs');
+const WIZARD_PATH = path.join(
+  __dirname, '..', '..', '..', 'src', 'wizard', 'index.js'
+);
+
+describe('IDE Sync Integration (Story INS-4.5)', () => {
+  let wizardSource;
+
+  beforeAll(() => {
+    wizardSource = fs.readFileSync(WIZARD_PATH, 'utf8');
+  });
+
+  describe('AC1: IDE sync called via adapter pattern', () => {
+    test('wizard imports commandSync and commandValidate from ide-sync', () => {
+      expect(wizardSource).toContain(
+        "const { commandSync, commandValidate } = require('../../../../.aios-core/infrastructure/scripts/ide-sync/index')"
+      );
+    });
+
+    test('wizard uses programmatic API (not child_process.exec)', () => {
+      // Should NOT shell out to ide-sync
+      expect(wizardSource).not.toMatch(/child_process.*ide-sync/);
+      expect(wizardSource).not.toMatch(/exec\(.*ide-sync/);
+      expect(wizardSource).not.toMatch(/spawn\(.*ide-sync/);
+    });
+
+    test('adapter pattern: saves cwd before calling commandSync', () => {
+      expect(wizardSource).toContain('const savedCwd = process.cwd()');
+    });
+
+    test('adapter pattern: uses explicit targetProjectRoot variable (not bare process.cwd())', () => {
+      expect(wizardSource).toContain('const targetProjectRoot = process.cwd()');
+      expect(wizardSource).toContain('process.chdir(targetProjectRoot)');
+    });
+
+    test('adapter pattern: restores cwd in finally block', () => {
+      // The finally block should restore savedCwd
+      expect(wizardSource).toContain('process.chdir(savedCwd)');
+      expect(wizardSource).toMatch(/finally\s*\{[^}]*process\.chdir\(savedCwd\)/s);
+    });
+
+    test('commandSync called with { quiet: true }', () => {
+      expect(wizardSource).toContain("await commandSync({ quiet: true })");
+    });
+
+    test('does NOT pass projectRoot or ides as parameters to commandSync', () => {
+      // commandSync uses process.cwd() internally — no projectRoot param
+      expect(wizardSource).not.toMatch(/commandSync\(\{[^}]*projectRoot/);
+      expect(wizardSource).not.toMatch(/commandSync\(\{[^}]*ides/);
+    });
+  });
+
+  describe('AC3: Graceful failure', () => {
+    test('sync failure is caught and does not propagate', () => {
+      // The try/catch should set ideSyncStatus to failed, not throw
+      expect(wizardSource).toContain("answers.ideSyncStatus = 'failed'");
+    });
+
+    test('failure message suggests aios doctor --fix', () => {
+      expect(wizardSource).toContain("aios doctor --fix");
+    });
+
+    test('install summary includes sync status on success', () => {
+      expect(wizardSource).toContain("answers.ideSyncStatus = 'synced'");
+    });
+
+    test('install summary includes sync status on failure', () => {
+      expect(wizardSource).toContain("answers.ideSyncStatus = 'failed'");
+    });
+  });
+
+  describe('AC4: Validate sync output', () => {
+    test('commandValidate called after commandSync', () => {
+      // commandValidate should appear after commandSync in the source
+      const syncIndex = wizardSource.indexOf('await commandSync({ quiet: true })');
+      const validateIndex = wizardSource.indexOf('await commandValidate(');
+      expect(syncIndex).toBeGreaterThan(-1);
+      expect(validateIndex).toBeGreaterThan(-1);
+      expect(validateIndex).toBeGreaterThan(syncIndex);
+    });
+
+    test('commandValidate uses same adapter pattern (within same finally block)', () => {
+      // Both commandSync and commandValidate should be within the same
+      // saved cwd / finally block
+      const savedCwdIndex = wizardSource.indexOf('const savedCwd = process.cwd()');
+      const syncIndex = wizardSource.indexOf('await commandSync({ quiet: true })');
+      const validateIndex = wizardSource.indexOf('await commandValidate(');
+      const finallyIndex = wizardSource.indexOf('process.chdir(savedCwd)');
+
+      // All should be in order: savedCwd < sync < validate < finally restore
+      expect(savedCwdIndex).toBeLessThan(syncIndex);
+      expect(syncIndex).toBeLessThan(validateIndex);
+      expect(validateIndex).toBeLessThan(finallyIndex);
+    });
+
+    test('validation drift logged as WARN not ERROR', () => {
+      expect(wizardSource).toContain("answers.ideSyncValidation = 'drift'");
+      // Should use console.warn, not console.error for drift
+      expect(wizardSource).toMatch(/console\.warn\(.*drift/i);
+    });
+
+    test('commandValidate console output suppressed (quiet workaround)', () => {
+      // commandValidate does not support quiet — wizard suppresses console.log
+      expect(wizardSource).toContain('const _origLog = console.log');
+      expect(wizardSource).toContain('console.log = () => {}');
+      // console.log must be restored in a finally block
+      expect(wizardSource).toContain('console.log = _origLog');
+    });
+  });
+
+  describe('AC5: Behavioral tests with mocks', () => {
+    beforeEach(() => {
+      mockCommandSync.mockReset();
+      mockCommandValidate.mockReset();
+    });
+
+    test('commandSync is called with { quiet: true } when invoked', async () => {
+      mockCommandSync.mockResolvedValue(undefined);
+      mockCommandValidate.mockResolvedValue(undefined);
+
+      // Simulate the adapter pattern call sequence
+      const savedCwd = process.cwd();
+      try {
+        await mockCommandSync({ quiet: true });
+        await mockCommandValidate({ quiet: true });
+      } finally {
+        process.chdir(savedCwd);
+      }
+
+      expect(mockCommandSync).toHaveBeenCalledWith({ quiet: true });
+      expect(mockCommandValidate).toHaveBeenCalledWith({ quiet: true });
+    });
+
+    test('commandSync failure does not throw — install continues', async () => {
+      mockCommandSync.mockRejectedValue(new Error('sync failed'));
+
+      let ideSyncStatus = 'unknown';
+      const savedCwd = process.cwd();
+      try {
+        process.chdir(process.cwd());
+        await mockCommandSync({ quiet: true });
+        ideSyncStatus = 'synced';
+      } catch (syncError) {
+        ideSyncStatus = 'failed';
+      } finally {
+        process.chdir(savedCwd);
+      }
+
+      // Install should continue — status is failed, no uncaught throw
+      expect(ideSyncStatus).toBe('failed');
+      expect(process.cwd()).toBe(savedCwd);
+    });
+
+    test('cwd is restored even when commandSync throws', async () => {
+      mockCommandSync.mockRejectedValue(new Error('sync failed'));
+      const originalCwd = process.cwd();
+
+      const savedCwd = process.cwd();
+      try {
+        process.chdir(process.cwd());
+        await mockCommandSync({ quiet: true });
+      } catch {
+        // Expected — sync failed
+      } finally {
+        process.chdir(savedCwd);
+      }
+
+      expect(process.cwd()).toBe(originalCwd);
+    });
+
+    test('commandValidate called after successful sync', async () => {
+      mockCommandSync.mockResolvedValue(undefined);
+      mockCommandValidate.mockResolvedValue(undefined);
+
+      const savedCwd = process.cwd();
+      let validateCalled = false;
+      try {
+        process.chdir(process.cwd());
+        await mockCommandSync({ quiet: true });
+        await mockCommandValidate({ quiet: true });
+        validateCalled = true;
+      } finally {
+        process.chdir(savedCwd);
+      }
+
+      expect(validateCalled).toBe(true);
+      expect(mockCommandValidate).toHaveBeenCalled();
+    });
+
+    test('commandValidate NOT called when commandSync fails', async () => {
+      mockCommandSync.mockRejectedValue(new Error('sync failed'));
+
+      const savedCwd = process.cwd();
+      try {
+        process.chdir(process.cwd());
+        await mockCommandSync({ quiet: true });
+        // This line should NOT be reached
+        await mockCommandValidate({ quiet: true });
+      } catch {
+        // Expected — sync failed, validate not called
+      } finally {
+        process.chdir(savedCwd);
+      }
+
+      expect(mockCommandSync).toHaveBeenCalled();
+      expect(mockCommandValidate).not.toHaveBeenCalled();
+    });
+  });
+});

package/packages/installer/tests/unit/merger/strategies.test.js

@@ -41,7 +41,7 @@ describe('getMergeStrategy', () => {
   });
 
   it('should return ReplaceMerger for unknown file types', () => {
-    const merger = getMergeStrategy('config.yaml');
+    const merger = getMergeStrategy('config.toml');
     expect(merger).toBeInstanceOf(ReplaceMerger);
   });
 
@@ -71,7 +71,7 @@ describe('hasMergeStrategy', () => {
   });
 
   it('should return false for unsupported files', () => {
-    expect(hasMergeStrategy('config.yaml')).toBe(false);
+    expect(hasMergeStrategy('config.toml')).toBe(false);
   });
 
   it('should return false for .json files', () => {

package/packages/installer/tests/unit/merger/yaml-merger.test.js

@@ -0,0 +1,327 @@
+'use strict';
+
+/**
+ * YAML Merger Strategy Tests (Story INS-4.7)
+ *
+ * Validates Phase 1 merge rules:
+ * - New keys added from source (framework)
+ * - User values preserved on conflict (target wins)
+ * - Deprecated keys kept with warning
+ * - Output is valid YAML
+ */
+
+const yaml = require('js-yaml');
+const path = require('path');
+const fs = require('fs');
+
+const { YamlMerger } = require(path.join(
+  __dirname, '..', '..', '..', 'src', 'merger', 'strategies', 'yaml-merger.js'
+));
+
+describe('YamlMerger (Story INS-4.7)', () => {
+  let merger;
+
+  beforeAll(() => {
+    merger = new YamlMerger();
+  });
+
+  describe('AC1: Strategy interface', () => {
+    test('extends BaseMerger with name "yaml"', () => {
+      expect(merger.name).toBe('yaml');
+    });
+
+    test('canMerge returns true for valid YAML', () => {
+      expect(merger.canMerge('key: value\n', 'other: data\n')).toBe(true);
+    });
+
+    test('canMerge returns false for invalid YAML', () => {
+      expect(merger.canMerge('key: value\n', '{{invalid')).toBe(false);
+    });
+
+    test('merge is async and returns MergeResult', async () => {
+      const result = await merger.merge('a: 1\n', 'a: 1\n');
+      expect(result).toHaveProperty('content');
+      expect(result).toHaveProperty('stats');
+      expect(result).toHaveProperty('changes');
+    });
+
+    test('getDescription returns meaningful text', () => {
+      expect(merger.getDescription()).toContain('YAML');
+      expect(merger.getDescription()).toContain('Phase 1');
+    });
+  });
+
+  describe('AC1: Strategy registration', () => {
+    test('.yaml extension registered in strategies/index.js', () => {
+      const { hasMergeStrategy, getMergeStrategy } = require(path.join(
+        __dirname, '..', '..', '..', 'src', 'merger', 'strategies', 'index.js'
+      ));
+
+      expect(hasMergeStrategy('config.yaml')).toBe(true);
+      const strategy = getMergeStrategy('config.yaml');
+      expect(strategy.name).toBe('yaml');
+    });
+
+    test('.yml extension also registered', () => {
+      const { hasMergeStrategy } = require(path.join(
+        __dirname, '..', '..', '..', 'src', 'merger', 'strategies', 'index.js'
+      ));
+
+      expect(hasMergeStrategy('config.yml')).toBe(true);
+    });
+
+    test('YamlMerger exported from merger/index.js', () => {
+      const mergerModule = require(path.join(
+        __dirname, '..', '..', '..', 'src', 'merger', 'index.js'
+      ));
+
+      expect(mergerModule.YamlMerger).toBeDefined();
+    });
+  });
+
+  describe('AC2: Phase 1 merge rules', () => {
+    test('new key in source → added to merged output', async () => {
+      const source = yaml.dump({ existingKey: 'a', newFeature: { enabled: true } });
+      const target = yaml.dump({ existingKey: 'a' });
+
+      const result = await merger.merge(source, target);
+      const merged = yaml.load(result.content);
+
+      expect(merged.newFeature).toEqual({ enabled: true });
+      expect(result.stats.added).toBeGreaterThanOrEqual(1);
+
+      const addedChange = result.changes.find(
+        c => c.type === 'added' && c.identifier === 'newFeature'
+      );
+      expect(addedChange).toBeDefined();
+    });
+
+    test('key in both with same value → target value preserved', async () => {
+      const source = yaml.dump({ key: 'same' });
+      const target = yaml.dump({ key: 'same' });
+
+      const result = await merger.merge(source, target);
+      const merged = yaml.load(result.content);
+
+      expect(merged.key).toBe('same');
+      expect(result.stats.preserved).toBeGreaterThanOrEqual(1);
+
+      const preservedChange = result.changes.find(
+        c => c.type === 'preserved' && c.identifier === 'key'
+      );
+      expect(preservedChange).toBeDefined();
+    });
+
+    test('conflict (different values) → target wins', async () => {
+      const source = yaml.dump({ setting: 'framework-default' });
+      const target = yaml.dump({ setting: 'user-custom' });
+
+      const result = await merger.merge(source, target);
+      const merged = yaml.load(result.content);
+
+      expect(merged.setting).toBe('user-custom');
+      expect(result.stats.conflicts).toBeGreaterThanOrEqual(1);
+
+      const conflictChange = result.changes.find(
+        c => c.type === 'conflict' && c.identifier === 'setting'
+      );
+      expect(conflictChange).toBeDefined();
+      expect(conflictChange.reason).toContain('Keeping user value');
+    });
+
+    test('deprecated key (in target, not in source) → kept with warning', async () => {
+      const source = yaml.dump({ current: true });
+      const target = yaml.dump({ current: true, legacyKey: 'old-value' });
+
+      const result = await merger.merge(source, target);
+      const merged = yaml.load(result.content);
+
+      expect(merged.legacyKey).toBe('old-value');
+
+      const deprecatedChange = result.changes.find(
+        c => c.type === 'conflict' && c.identifier === 'legacyKey'
+      );
+      expect(deprecatedChange).toBeDefined();
+      expect(deprecatedChange.reason).toContain('Deprecated');
+    });
+
+    test('output is valid YAML', async () => {
+      const source = yaml.dump({ a: 1, b: { c: 2 }, d: [1, 2, 3] });
+      const target = yaml.dump({ a: 99, e: 'user' });
+
+      const result = await merger.merge(source, target);
+
+      expect(() => yaml.load(result.content)).not.toThrow();
+    });
+
+    test('all changes in MergeResult.changes array (no separate warnings)', async () => {
+      const source = yaml.dump({ a: 1, b: 2 });
+      const target = yaml.dump({ a: 99, c: 3 });
+
+      const result = await merger.merge(source, target);
+
+      expect(result).not.toHaveProperty('warnings');
+      expect(Array.isArray(result.changes)).toBe(true);
+      expect(result.changes.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('AC2: Deep merge', () => {
+    test('nested new keys added at depth', async () => {
+      const source = yaml.dump({
+        boundary: { frameworkProtection: true, newSetting: 'added' },
+      });
+      const target = yaml.dump({
+        boundary: { frameworkProtection: false },
+      });
+
+      const result = await merger.merge(source, target);
+      const merged = yaml.load(result.content);
+
+      expect(merged.boundary.frameworkProtection).toBe(false); // user wins
+      expect(merged.boundary.newSetting).toBe('added'); // new key added
+    });
+
+    test('nested conflict preserves user value', async () => {
+      const source = yaml.dump({
+        pvMindContext: { location: 'default-path' },
+      });
+      const target = yaml.dump({
+        pvMindContext: { location: 'user-custom-path' },
+      });
+
+      const result = await merger.merge(source, target);
+      const merged = yaml.load(result.content);
+
+      expect(merged.pvMindContext.location).toBe('user-custom-path');
+    });
+  });
+
+  describe('AC4: User config preservation', () => {
+    test('custom pvMindContext.location preserved after upgrade', async () => {
+      const source = yaml.dump({
+        project: { type: 'EXISTING_AIOS', version: '2.2.0' },
+        pvMindContext: { location: 'default' },
+      });
+      const target = yaml.dump({
+        project: { type: 'EXISTING_AIOS', version: '2.1.0' },
+        pvMindContext: { location: '/my/custom/path' },
+      });
+
+      const result = await merger.merge(source, target);
+      const merged = yaml.load(result.content);
+
+      expect(merged.pvMindContext.location).toBe('/my/custom/path');
+    });
+
+    test('new framework key added alongside preserved user config', async () => {
+      const source = yaml.dump({
+        existing: 'value',
+        someNewFeature: { enabled: true },
+      });
+      const target = yaml.dump({
+        existing: 'value',
+      });
+
+      const result = await merger.merge(source, target);
+      const merged = yaml.load(result.content);
+
+      expect(merged.existing).toBe('value');
+      expect(merged.someNewFeature).toEqual({ enabled: true });
+    });
+  });
+
+  describe('AC5: Boundary section preservation', () => {
+    test('user-customized boundary paths NOT removed', async () => {
+      const source = yaml.dump({
+        boundary: {
+          frameworkProtection: true,
+          protected: ['.aios-core/core/'],
+        },
+      });
+      const target = yaml.dump({
+        boundary: {
+          frameworkProtection: false,
+          protected: ['.aios-core/core/', 'my-custom-path/'],
+          exceptions: ['my-exception/'],
+        },
+      });
+
+      const result = await merger.merge(source, target);
+      const merged = yaml.load(result.content);
+
+      // User boundary values preserved (target wins on arrays — no deep array merge)
+      expect(merged.boundary.frameworkProtection).toBe(false);
+      expect(merged.boundary.protected).toContain('my-custom-path/');
+      expect(merged.boundary.exceptions).toContain('my-exception/');
+    });
+  });
+
+  describe('AC6: Edge cases', () => {
+    test('empty source → target preserved as-is', async () => {
+      const source = '';
+      const target = yaml.dump({ user: 'config' });
+
+      const result = await merger.merge(source, target);
+      const merged = yaml.load(result.content);
+
+      expect(merged.user).toBe('config');
+    });
+
+    test('empty target → source keys added', async () => {
+      const source = yaml.dump({ framework: 'config' });
+      const target = '';
+
+      const result = await merger.merge(source, target);
+      const merged = yaml.load(result.content);
+
+      expect(merged.framework).toBe('config');
+    });
+
+    test('arrays treated as scalar (target wins, not merged)', async () => {
+      const source = yaml.dump({ list: [1, 2, 3] });
+      const target = yaml.dump({ list: [4, 5] });
+
+      const result = await merger.merge(source, target);
+      const merged = yaml.load(result.content);
+
+      expect(merged.list).toEqual([4, 5]); // target wins
+    });
+  });
+});
+
+describe('Brownfield Upgrader Integration (Story INS-4.7)', () => {
+  test('brownfield-upgrader imports YamlMerger', () => {
+    const upgraderSource = fs.readFileSync(
+      path.join(__dirname, '..', '..', '..', 'src', 'installer', 'brownfield-upgrader.js'),
+      'utf8'
+    );
+    expect(upgraderSource).toContain('YamlMerger');
+    expect(upgraderSource).toContain('yaml-merger.js');
+  });
+
+  test('upgrader has core-config.yaml merge exception in userModifiedFiles loop', () => {
+    const upgraderSource = fs.readFileSync(
+      path.join(__dirname, '..', '..', '..', 'src', 'installer', 'brownfield-upgrader.js'),
+      'utf8'
+    );
+    expect(upgraderSource).toContain("file.path.endsWith('core-config.yaml')");
+    expect(upgraderSource).toContain('merger.merge(sourceContent, targetContent)');
+    expect(upgraderSource).toContain('.backup-');
+  });
+
+  test('upgrader still skips non-yaml user-modified files', () => {
+    const upgraderSource = fs.readFileSync(
+      path.join(__dirname, '..', '..', '..', 'src', 'installer', 'brownfield-upgrader.js'),
+      'utf8'
+    );
+    expect(upgraderSource).toContain('User modified - preserving local changes');
+  });
+});
+
+describe('Existing strategies still work', () => {
+  test('strategies.test.js file exists (regression guard)', () => {
+    const testPath = path.join(__dirname, 'strategies.test.js');
+    expect(fs.existsSync(testPath)).toBe(true);
+  });
+});