xp-gate 0.5.1

package/lib/__tests__/rollback.test.js

@@ -0,0 +1,183 @@
+/**
+ * @test rollback
+ * @intent Verify rollback(), createBackup(), cleanupBackup() correctly backup and restore skill directories
+ */
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+describe('rollback', () => {
+  let tmpHome;
+  let originalHome;
+  let logSpy;
+
+  beforeEach(() => {
+    originalHome = process.env.HOME;
+    tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'xpgate-rb-'));
+    process.env.HOME = tmpHome;
+    vi.resetModules();
+    delete require.cache[require.resolve('../rollback')];
+    logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    process.env.HOME = originalHome;
+    fs.rmSync(tmpHome, { recursive: true, force: true });
+    vi.restoreAllMocks();
+  });
+
+  function skillsDir() {
+    return path.join(tmpHome, '.config', 'opencode', 'skills');
+  }
+
+  function backupRoot() {
+    return path.join(tmpHome, '.config', 'xp-gate', 'backup');
+  }
+
+  describe('createBackup', () => {
+    it('returns null when targetDir does not exist', async () => {
+      const { createBackup } = require('../rollback');
+      const result = await createBackup('install-1', 'nonexistent-skill');
+      expect(result).toBeNull();
+    });
+
+    it('copies dir contents (files) into backup when targetDir exists', async () => {
+      const target = path.join(skillsDir(), 'my-skill');
+      fs.mkdirSync(target, { recursive: true });
+      fs.writeFileSync(path.join(target, 'SKILL.md'), 'content-a');
+      fs.writeFileSync(path.join(target, 'README.md'), 'content-b');
+
+      const { createBackup } = require('../rollback');
+      const backupPath = await createBackup('install-1', 'my-skill');
+
+      expect(backupPath).toBe(path.join(backupRoot(), 'install-1'));
+      expect(fs.existsSync(path.join(backupPath, 'SKILL.md'))).toBe(true);
+      expect(fs.existsSync(path.join(backupPath, 'README.md'))).toBe(true);
+      expect(fs.readFileSync(path.join(backupPath, 'SKILL.md'), 'utf8')).toBe('content-a');
+    });
+
+    it('copies nested directories recursively', async () => {
+      const target = path.join(skillsDir(), 'nested-skill');
+      fs.mkdirSync(path.join(target, 'subdir', 'deeper'), { recursive: true });
+      fs.writeFileSync(path.join(target, 'top.txt'), 'top');
+      fs.writeFileSync(path.join(target, 'subdir', 'mid.txt'), 'mid');
+      fs.writeFileSync(path.join(target, 'subdir', 'deeper', 'bottom.txt'), 'bottom');
+
+      const { createBackup } = require('../rollback');
+      const backupPath = await createBackup('install-2', 'nested-skill');
+
+      expect(fs.readFileSync(path.join(backupPath, 'top.txt'), 'utf8')).toBe('top');
+      expect(fs.readFileSync(path.join(backupPath, 'subdir', 'mid.txt'), 'utf8')).toBe('mid');
+      expect(
+        fs.readFileSync(path.join(backupPath, 'subdir', 'deeper', 'bottom.txt'), 'utf8')
+      ).toBe('bottom');
+    });
+  });
+
+  describe('rollback', () => {
+    it('is no-op when backup dir does not exist', async () => {
+      const { rollback } = require('../rollback');
+      await rollback('nonexistent-install');
+      expect(logSpy).not.toHaveBeenCalled();
+    });
+
+    it('restores files from backup to skills dir', async () => {
+      // Setup: create backup with one skill entry
+      const backupDir = path.join(backupRoot(), 'install-3');
+      const backupEntry = path.join(backupDir, 'restored-skill');
+      fs.mkdirSync(backupEntry, { recursive: true });
+      fs.writeFileSync(path.join(backupEntry, 'SKILL.md'), 'restored content');
+
+      // Ensure skills dir exists (parent of dest must exist for renameSync)
+      fs.mkdirSync(skillsDir(), { recursive: true });
+
+      const { rollback } = require('../rollback');
+      await rollback('install-3');
+
+      const dest = path.join(skillsDir(), 'restored-skill');
+      expect(fs.existsSync(dest)).toBe(true);
+      expect(fs.readFileSync(path.join(dest, 'SKILL.md'), 'utf8')).toBe('restored content');
+      // Backup dir removed after rollback
+      expect(fs.existsSync(backupDir)).toBe(false);
+      expect(logSpy).toHaveBeenCalledWith('Rolling back...');
+      expect(logSpy).toHaveBeenCalledWith('Rollback complete');
+    });
+
+    it('removes existing dest before restoring from backup', async () => {
+      // Pre-existing skill (newer version) that should be overwritten by rollback
+      const dest = path.join(skillsDir(), 'overwrite-skill');
+      fs.mkdirSync(dest, { recursive: true });
+      fs.writeFileSync(path.join(dest, 'NEW.md'), 'new content');
+
+      // Backup with old version
+      const backupDir = path.join(backupRoot(), 'install-4');
+      const backupEntry = path.join(backupDir, 'overwrite-skill');
+      fs.mkdirSync(backupEntry, { recursive: true });
+      fs.writeFileSync(path.join(backupEntry, 'OLD.md'), 'old content');
+
+      const { rollback } = require('../rollback');
+      await rollback('install-4');
+
+      // NEW.md should be gone, OLD.md restored
+      expect(fs.existsSync(path.join(dest, 'NEW.md'))).toBe(false);
+      expect(fs.existsSync(path.join(dest, 'OLD.md'))).toBe(true);
+      expect(fs.readFileSync(path.join(dest, 'OLD.md'), 'utf8')).toBe('old content');
+    });
+
+    it('handles multiple skill entries in single backup', async () => {
+      const backupDir = path.join(backupRoot(), 'install-5');
+      fs.mkdirSync(path.join(backupDir, 'skill-a'), { recursive: true });
+      fs.mkdirSync(path.join(backupDir, 'skill-b'), { recursive: true });
+      fs.writeFileSync(path.join(backupDir, 'skill-a', 'a.md'), 'A');
+      fs.writeFileSync(path.join(backupDir, 'skill-b', 'b.md'), 'B');
+
+      fs.mkdirSync(skillsDir(), { recursive: true });
+
+      const { rollback } = require('../rollback');
+      await rollback('install-5');
+
+      expect(fs.existsSync(path.join(skillsDir(), 'skill-a', 'a.md'))).toBe(true);
+      expect(fs.existsSync(path.join(skillsDir(), 'skill-b', 'b.md'))).toBe(true);
+    });
+  });
+
+  describe('cleanupBackup', () => {
+    it('removes backup dir when it exists', async () => {
+      const backupDir = path.join(backupRoot(), 'install-6');
+      fs.mkdirSync(backupDir, { recursive: true });
+      fs.writeFileSync(path.join(backupDir, 'stale.txt'), 'stale');
+
+      const { cleanupBackup } = require('../rollback');
+      cleanupBackup('install-6');
+
+      expect(fs.existsSync(backupDir)).toBe(false);
+    });
+
+    it('is no-op when backup dir does not exist', async () => {
+      const { cleanupBackup } = require('../rollback');
+      // Should not throw
+      expect(() => cleanupBackup('nonexistent-id')).not.toThrow();
+    });
+  });
+
+  describe('round trip: createBackup + rollback', () => {
+    it('createBackup writes entries that rollback restores as top-level skills', async () => {
+      const target = path.join(skillsDir(), 'roundtrip-skill');
+      fs.mkdirSync(target, { recursive: true });
+      fs.writeFileSync(path.join(target, 'v1.txt'), 'version 1');
+
+      const { createBackup, rollback } = require('../rollback');
+      await createBackup('rt-install', 'roundtrip-skill');
+
+      const backupDir = path.join(backupRoot(), 'rt-install');
+      expect(fs.existsSync(path.join(backupDir, 'v1.txt'))).toBe(true);
+
+      fs.unlinkSync(path.join(target, 'v1.txt'));
+
+      await rollback('rt-install');
+
+      expect(fs.existsSync(path.join(skillsDir(), 'v1.txt'))).toBe(true);
+      expect(fs.readFileSync(path.join(skillsDir(), 'v1.txt'), 'utf8')).toBe('version 1');
+    });
+  });
+});

package/lib/__tests__/ui-detector.test.ts

@@ -0,0 +1,200 @@
+/**
+ * @test ui-detector
+ * @intent Verify detectUiSprint correctly identifies UI file changes
+ */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { execSync } from 'child_process';
+
+vi.mock('child_process', () => ({
+  execSync: vi.fn(),
+}));
+
+const mockExecSync = vi.mocked(execSync);
+
+describe('ui-detector', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('detectUiSprint', () => {
+    it('should return false for empty diff', async () => {
+      mockExecSync.mockReturnValue('');
+      const { detectUiSprint } = await import('../ui-detector');
+      const result = detectUiSprint();
+      expect(result.isUiSprint).toBe(false);
+      expect(result.matchedFiles).toEqual([]);
+      expect(result.matchedRules).toEqual([]);
+    });
+
+    it('should return false for pure backend changes', async () => {
+      mockExecSync.mockReturnValue('src/auth.ts\nsrc/db.ts\n');
+      const { detectUiSprint } = await import('../ui-detector');
+      const result = detectUiSprint('main');
+      expect(result.isUiSprint).toBe(false);
+    });
+
+    it('should return true for template files in view directories', async () => {
+      mockExecSync.mockReturnValue('views/index.njk\n');
+      const { detectUiSprint } = await import('../ui-detector');
+      const result = detectUiSprint();
+      expect(result.isUiSprint).toBe(true);
+      expect(result.matchedFiles).toContain('views/index.njk');
+      expect(result.matchedRules.some(r => r.includes('template'))).toBe(true);
+    });
+
+    it('should return true for component files in view directories', async () => {
+      mockExecSync.mockReturnValue('src/components/Button.tsx\n');
+      const { detectUiSprint } = await import('../ui-detector');
+      const result = detectUiSprint();
+      expect(result.isUiSprint).toBe(true);
+      expect(result.matchedFiles).toContain('src/components/Button.tsx');
+    });
+
+    it('should return false for component files NOT in view directories', async () => {
+      mockExecSync.mockReturnValue('src/hooks/useAuth.tsx\n');
+      const { detectUiSprint } = await import('../ui-detector');
+      const result = detectUiSprint();
+      expect(result.isUiSprint).toBe(false);
+    });
+
+    it('should return true for style files in view directories', async () => {
+      mockExecSync.mockReturnValue('views/styles/main.css\n');
+      const { detectUiSprint } = await import('../ui-detector');
+      const result = detectUiSprint();
+      expect(result.isUiSprint).toBe(true);
+    });
+
+    it('should return false for style files NOT in view directories', async () => {
+      mockExecSync.mockReturnValue('src/index.css\n');
+      const { detectUiSprint } = await import('../ui-detector');
+      const result = detectUiSprint();
+      expect(result.isUiSprint).toBe(false);
+    });
+
+    it('should return true for mixed changes (backend + UI)', async () => {
+      mockExecSync.mockReturnValue('src/auth.ts\nviews/login.html\n');
+      const { detectUiSprint } = await import('../ui-detector');
+      const result = detectUiSprint();
+      expect(result.isUiSprint).toBe(true);
+      expect(result.matchedFiles).toContain('views/login.html');
+    });
+
+    it('should return true for deleted UI files', async () => {
+      mockExecSync.mockReturnValue('views/old.html\n');
+      const { detectUiSprint } = await import('../ui-detector');
+      const result = detectUiSprint();
+      expect(result.isUiSprint).toBe(true);
+    });
+
+    it('should handle renamed files correctly', async () => {
+      mockExecSync.mockReturnValue('views/a.html → views/b.html\n');
+      const { detectUiSprint } = await import('../ui-detector');
+      const result = detectUiSprint();
+      expect(result.isUiSprint).toBe(true);
+      expect(result.matchedFiles).toContain('views/b.html');
+    });
+
+    it('should return false for pure documentation changes', async () => {
+      mockExecSync.mockReturnValue('docs/README.md\n');
+      const { detectUiSprint } = await import('../ui-detector');
+      const result = detectUiSprint();
+      expect(result.isUiSprint).toBe(false);
+    });
+
+    it('should use main as default base branch', async () => {
+      mockExecSync.mockReturnValue('');
+      const { detectUiSprint } = await import('../ui-detector');
+      detectUiSprint();
+      expect(mockExecSync).toHaveBeenCalledWith(
+        expect.stringContaining('git diff --name-only main..HEAD'),
+        expect.any(Object)
+      );
+    });
+
+    it('should handle git command failure gracefully', async () => {
+      mockExecSync.mockImplementation(() => {
+        throw new Error('git not available');
+      });
+      const { detectUiSprint } = await import('../ui-detector');
+      const result = detectUiSprint();
+      expect(result.isUiSprint).toBe(false);
+    });
+
+    it('should handle multiple UI files across different types', async () => {
+      mockExecSync.mockReturnValue('views/index.njk\nsrc/components/Button.tsx\nsrc/auth.ts\n');
+      const { detectUiSprint } = await import('../ui-detector');
+      const result = detectUiSprint();
+      expect(result.isUiSprint).toBe(true);
+      expect(result.matchedFiles.length).toBe(2);
+    });
+  });
+
+  describe('parseRenamedFile', () => {
+    it('should extract new path from renamed file', async () => {
+      const { parseRenamedFile } = await import('../ui-detector');
+      expect(parseRenamedFile('views/a.html → views/b.html')).toBe('views/b.html');
+    });
+
+    it('should return original path for non-renamed files', async () => {
+      const { parseRenamedFile } = await import('../ui-detector');
+      expect(parseRenamedFile('src/auth.ts')).toBe('src/auth.ts');
+    });
+  });
+
+  describe('getFileExtension', () => {
+    it('should extract file extension', async () => {
+      const { getFileExtension } = await import('../ui-detector');
+      expect(getFileExtension('src/auth.ts')).toBe('.ts');
+      expect(getFileExtension('views/index.njk')).toBe('.njk');
+      expect(getFileExtension('styles/main.css')).toBe('.css');
+    });
+
+    it('should return empty string for files without extension', async () => {
+      const { getFileExtension } = await import('../ui-detector');
+      expect(getFileExtension('Makefile')).toBe('');
+    });
+  });
+
+  describe('hasUiPathPattern', () => {
+    it('should return true for views/ directory', async () => {
+      const { hasUiPathPattern } = await import('../ui-detector');
+      expect(hasUiPathPattern('views/index.html')).toBe(true);
+    });
+
+    it('should return true for components/ directory', async () => {
+      const { hasUiPathPattern } = await import('../ui-detector');
+      expect(hasUiPathPattern('src/components/button.tsx')).toBe(true);
+    });
+
+    it('should return false for non-UI paths', async () => {
+      const { hasUiPathPattern } = await import('../ui-detector');
+      expect(hasUiPathPattern('src/utils/helper.ts')).toBe(false);
+    });
+  });
+
+  describe('getFileMatchRules', () => {
+    it('should return template rule for .html files', async () => {
+      const { getFileMatchRules } = await import('../ui-detector');
+      const rules = getFileMatchRules('views/index.html');
+      expect(rules).toContain('template-.html');
+    });
+
+    it('should return component rule for .tsx in components/', async () => {
+      const { getFileMatchRules } = await import('../ui-detector');
+      const rules = getFileMatchRules('src/components/Button.tsx');
+      expect(rules).toContain('component-.tsx');
+    });
+
+    it('should return empty for .tsx outside UI directories', async () => {
+      const { getFileMatchRules } = await import('../ui-detector');
+      const rules = getFileMatchRules('src/hooks/useAuth.tsx');
+      expect(rules).toEqual([]);
+    });
+
+    it('should return style rule for .css in views/', async () => {
+      const { getFileMatchRules } = await import('../ui-detector');
+      const rules = getFileMatchRules('views/styles/main.css');
+      expect(rules).toContain('style-.css');
+    });
+  });
+});

package/lib/__tests__/uninstall-skill.test.js

@@ -0,0 +1,189 @@
+/**
+ * @test uninstall-skill
+ * @intent Verify uninstallSkill() correctly removes skills, cleans cache, and updates config
+ */
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+describe('uninstall-skill', () => {
+  let tmpHome;
+  let originalHome;
+  let logSpy;
+  let errorSpy;
+
+  beforeEach(() => {
+    originalHome = process.env.HOME;
+    tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'xpgate-un-'));
+    process.env.HOME = tmpHome;
+    vi.resetModules();
+    delete require.cache[require.resolve('../uninstall-skill')];
+    logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    process.env.HOME = originalHome;
+    fs.rmSync(tmpHome, { recursive: true, force: true });
+    vi.restoreAllMocks();
+  });
+
+  function skillsDir() {
+    return path.join(tmpHome, '.config', 'opencode', 'skills');
+  }
+
+  function configDir() {
+    return path.join(tmpHome, '.config', 'xp-gate');
+  }
+
+  function cacheDir() {
+    return path.join(configDir(), 'cache');
+  }
+
+  function makeInstalledSkill(name) {
+    const dir = path.join(skillsDir(), name);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(path.join(dir, 'SKILL.md'), 'content');
+    return dir;
+  }
+
+  it('returns 1 + console.error when name is empty', async () => {
+    const { uninstallSkill } = require('../uninstall-skill');
+    const result = await uninstallSkill();
+    expect(result).toBe(1);
+    expect(errorSpy).toHaveBeenCalledWith('Error: Skill name required');
+    expect(errorSpy).toHaveBeenCalledWith('Usage: xp-gate uninstall-skill <name> [--force]');
+  });
+
+  it('returns 1 + console.error when name is empty string', async () => {
+    const { uninstallSkill } = require('../uninstall-skill');
+    const result = await uninstallSkill('');
+    expect(result).toBe(1);
+    expect(errorSpy).toHaveBeenCalled();
+  });
+
+  it('returns 1 when skill is not installed', async () => {
+    const { uninstallSkill } = require('../uninstall-skill');
+    const result = await uninstallSkill('not-installed');
+    expect(result).toBe(1);
+    expect(errorSpy).toHaveBeenCalledWith('Error: not-installed is not installed');
+  });
+
+  it('returns 0 and prompts (no deletion) when force=false', async () => {
+    const dir = makeInstalledSkill('foo');
+    const { uninstallSkill } = require('../uninstall-skill');
+    const result = await uninstallSkill('foo');
+    expect(result).toBe(0);
+    expect(fs.existsSync(dir)).toBe(true); // NOT deleted
+    expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('Uninstall foo?'));
+    expect(logSpy).toHaveBeenCalledWith('Use --force to skip confirmation');
+  });
+
+  it('returns 0 and removes skill dir when force=true', async () => {
+    const dir = makeInstalledSkill('foo');
+    const { uninstallSkill } = require('../uninstall-skill');
+    const result = await uninstallSkill('foo', { force: true });
+    expect(result).toBe(0);
+    expect(fs.existsSync(dir)).toBe(false);
+    expect(logSpy).toHaveBeenCalledWith('Removing foo...');
+    expect(logSpy).toHaveBeenCalledWith('✓ foo uninstalled');
+  });
+
+  it('removes cache file (foo.tgz) when force=true', async () => {
+    makeInstalledSkill('foo');
+    fs.mkdirSync(cacheDir(), { recursive: true });
+    const cacheFile = path.join(cacheDir(), 'foo.tgz');
+    fs.writeFileSync(cacheFile, 'cached-tgz-data');
+
+    const { uninstallSkill } = require('../uninstall-skill');
+    const result = await uninstallSkill('foo', { force: true });
+    expect(result).toBe(0);
+    expect(fs.existsSync(cacheFile)).toBe(false);
+  });
+
+  it('does not error when no cache file exists', async () => {
+    makeInstalledSkill('foo');
+    // No cache dir created
+    const { uninstallSkill } = require('../uninstall-skill');
+    const result = await uninstallSkill('foo', { force: true });
+    expect(result).toBe(0);
+  });
+
+  it('removes skill entry from installedSkills in config when force=true', async () => {
+    makeInstalledSkill('foo');
+    fs.mkdirSync(configDir(), { recursive: true });
+    const configFile = path.join(configDir(), 'xp-gate.json');
+    fs.writeFileSync(
+      configFile,
+      JSON.stringify({
+        installedSkills: { foo: { version: '1.0.0' }, bar: { version: '2.0.0' } },
+        otherSetting: true,
+      })
+    );
+
+    const { uninstallSkill } = require('../uninstall-skill');
+    const result = await uninstallSkill('foo', { force: true });
+    expect(result).toBe(0);
+
+    const written = JSON.parse(fs.readFileSync(configFile, 'utf8'));
+    expect(written.installedSkills).not.toHaveProperty('foo');
+    expect(written.installedSkills).toHaveProperty('bar');
+    expect(written.otherSetting).toBe(true);
+  });
+
+  it('does not write config when no installedSkills key present', async () => {
+    makeInstalledSkill('foo');
+    fs.mkdirSync(configDir(), { recursive: true });
+    const configFile = path.join(configDir(), 'xp-gate.json');
+    fs.writeFileSync(configFile, JSON.stringify({ otherSetting: 'unchanged' }));
+
+    const { uninstallSkill } = require('../uninstall-skill');
+    const result = await uninstallSkill('foo', { force: true });
+    expect(result).toBe(0);
+
+    const written = JSON.parse(fs.readFileSync(configFile, 'utf8'));
+    expect(written.otherSetting).toBe('unchanged');
+    expect(written).not.toHaveProperty('installedSkills');
+  });
+
+  it('handles missing config file gracefully (getConfig returns {})', async () => {
+    makeInstalledSkill('foo');
+    // No config file
+    const { uninstallSkill } = require('../uninstall-skill');
+    const result = await uninstallSkill('foo', { force: true });
+    expect(result).toBe(0);
+    // No config file should be created (since config = {} has no installedSkills)
+    expect(fs.existsSync(path.join(configDir(), 'xp-gate.json'))).toBe(false);
+  });
+
+  it('handles malformed config JSON gracefully (catch swallows + returns {})', async () => {
+    makeInstalledSkill('foo');
+    fs.mkdirSync(configDir(), { recursive: true });
+    fs.writeFileSync(path.join(configDir(), 'xp-gate.json'), '{invalid json');
+
+    const { uninstallSkill } = require('../uninstall-skill');
+    const result = await uninstallSkill('foo', { force: true });
+    expect(result).toBe(0);
+  });
+
+  it('removes cache file + skill dir + config entry in one call (full path)', async () => {
+    const dir = makeInstalledSkill('full');
+    fs.mkdirSync(cacheDir(), { recursive: true });
+    const cacheFile = path.join(cacheDir(), 'full.tgz');
+    fs.writeFileSync(cacheFile, 'data');
+    const configFile = path.join(configDir(), 'xp-gate.json');
+    fs.writeFileSync(
+      configFile,
+      JSON.stringify({ installedSkills: { full: { version: '1.0.0' } } })
+    );
+
+    const { uninstallSkill } = require('../uninstall-skill');
+    const result = await uninstallSkill('full', { force: true });
+
+    expect(result).toBe(0);
+    expect(fs.existsSync(dir)).toBe(false);
+    expect(fs.existsSync(cacheFile)).toBe(false);
+    const written = JSON.parse(fs.readFileSync(configFile, 'utf8'));
+    expect(written.installedSkills).not.toHaveProperty('full');
+  });
+});