xp-gate 0.5.1

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

@@ -0,0 +1,276 @@
+/**
+ * @test update-skill
+ * @intent Verify updateSkill() handles check/all/single-name modes, config parsing, and delegates to installSkill correctly
+ */
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+describe('update-skill', () => {
+  let tmpHome;
+  let originalHome;
+  let logSpy;
+  let errorSpy;
+  let installSkillMock;
+
+  beforeEach(() => {
+    originalHome = process.env.HOME;
+    tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'xpgate-up-'));
+    process.env.HOME = tmpHome;
+
+    vi.resetModules();
+    delete require.cache[require.resolve('../update-skill')];
+    delete require.cache[require.resolve('../install-skill.js')];
+
+    // Inject mock install-skill module into the require.cache BEFORE update-skill
+    // pulls it in (it lazy-requires it inside updateSingleSkill).
+    installSkillMock = vi.fn().mockResolvedValue(0);
+    const installSkillPath = require.resolve('../install-skill.js');
+    require.cache[installSkillPath] = {
+      id: installSkillPath,
+      filename: installSkillPath,
+      loaded: true,
+      exports: { installSkill: installSkillMock },
+    };
+
+    logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    process.env.HOME = originalHome;
+    fs.rmSync(tmpHome, { recursive: true, force: true });
+    delete require.cache[require.resolve('../install-skill.js')];
+    delete require.cache[require.resolve('../update-skill')];
+    vi.restoreAllMocks();
+  });
+
+  function configDir() {
+    return path.join(tmpHome, '.config', 'xp-gate');
+  }
+
+  function skillsDir() {
+    return path.join(tmpHome, '.config', 'opencode', 'skills');
+  }
+
+  function writeConfig(skills) {
+    fs.mkdirSync(configDir(), { recursive: true });
+    fs.writeFileSync(
+      path.join(configDir(), 'xp-gate.json'),
+      JSON.stringify({ installedSkills: skills })
+    );
+  }
+
+  function makeSkillDir(name) {
+    const dir = path.join(skillsDir(), name);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(path.join(dir, 'SKILL.md'), 'old content');
+    return dir;
+  }
+
+  // ----- name + flags validation -----
+
+  it('returns 1 + console.error when name is null and no flags', async () => {
+    const { updateSkill } = require('../update-skill');
+    const result = await updateSkill(null);
+    expect(result).toBe(1);
+    expect(errorSpy).toHaveBeenCalledWith('Error: Skill name required');
+    expect(errorSpy).toHaveBeenCalledWith(
+      'Usage: xp-gate update-skill <name> or --all'
+    );
+  });
+
+  it('returns 1 + console.error when name is undefined and no flags', async () => {
+    const { updateSkill } = require('../update-skill');
+    const result = await updateSkill();
+    expect(result).toBe(1);
+    expect(errorSpy).toHaveBeenCalledWith('Error: Skill name required');
+  });
+
+  it('returns 1 + "is not installed" when name not in config.installedSkills', async () => {
+    writeConfig({}); // empty
+    const { updateSkill } = require('../update-skill');
+    const result = await updateSkill('foo');
+    expect(result).toBe(1);
+    expect(errorSpy).toHaveBeenCalledWith('Error: foo is not installed');
+  });
+
+  it('returns 1 + "is not installed" when config file is missing entirely', async () => {
+    const { updateSkill } = require('../update-skill');
+    const result = await updateSkill('foo');
+    expect(result).toBe(1);
+    expect(errorSpy).toHaveBeenCalledWith('Error: foo is not installed');
+  });
+
+  // ----- check mode -----
+
+  it('check=true prints each installed skill with its version, returns 0', async () => {
+    writeConfig({
+      foo: { version: '1.2.3' },
+      bar: { version: '2.0.0' },
+    });
+    const { updateSkill } = require('../update-skill');
+    const result = await updateSkill(null, { check: true });
+    expect(result).toBe(0);
+    expect(logSpy).toHaveBeenCalledWith('Checking for updates...');
+    expect(logSpy).toHaveBeenCalledWith('  foo: 1.2.3');
+    expect(logSpy).toHaveBeenCalledWith('  bar: 2.0.0');
+    expect(logSpy).toHaveBeenCalledWith('Update check complete');
+  });
+
+  it('check=true with skill missing version falls back to "unknown"', async () => {
+    writeConfig({ baz: {} }); // no version field
+    const { updateSkill } = require('../update-skill');
+    const result = await updateSkill(null, { check: true });
+    expect(result).toBe(0);
+    expect(logSpy).toHaveBeenCalledWith('  baz: unknown');
+  });
+
+  it('check=true with empty config returns 0 and prints only headers', async () => {
+    const { updateSkill } = require('../update-skill');
+    const result = await updateSkill(null, { check: true });
+    expect(result).toBe(0);
+    expect(logSpy).toHaveBeenCalledWith('Checking for updates...');
+    expect(logSpy).toHaveBeenCalledWith('Update check complete');
+  });
+
+  // ----- all mode -----
+
+  it('all=true with empty skills returns 0 and prints "Updating all skills..."', async () => {
+    const { updateSkill } = require('../update-skill');
+    const result = await updateSkill(null, { all: true });
+    expect(result).toBe(0);
+    expect(logSpy).toHaveBeenCalledWith('Updating all skills...');
+    expect(installSkillMock).not.toHaveBeenCalled();
+  });
+
+  it('all=true updates every installed skill (calls installSkill each), returns 0 on success', async () => {
+    writeConfig({
+      foo: { version: '1.0.0' },
+      bar: { version: '1.0.0' },
+    });
+    const { updateSkill } = require('../update-skill');
+    const result = await updateSkill(null, { all: true });
+    expect(result).toBe(0);
+    expect(installSkillMock).toHaveBeenCalledTimes(2);
+    expect(installSkillMock).toHaveBeenCalledWith('foo', {
+      force: true,
+      verbose: false,
+    });
+    expect(installSkillMock).toHaveBeenCalledWith('bar', {
+      force: true,
+      verbose: false,
+    });
+    expect(logSpy).toHaveBeenCalledWith('Updating foo...');
+    expect(logSpy).toHaveBeenCalledWith('Updating bar...');
+    expect(logSpy).toHaveBeenCalledWith('✓ foo updated');
+    expect(logSpy).toHaveBeenCalledWith('✓ bar updated');
+  });
+
+  it('all=true returns 1 when at least one installSkill rejects', async () => {
+    writeConfig({
+      good: { version: '1.0.0' },
+      bad: { version: '1.0.0' },
+    });
+    installSkillMock.mockImplementation(async (name) => {
+      if (name === 'bad') throw new Error('boom');
+      return 0;
+    });
+    const { updateSkill } = require('../update-skill');
+    const result = await updateSkill(null, { all: true });
+    expect(result).toBe(1);
+    expect(errorSpy).toHaveBeenCalledWith('Failed to update bad: boom');
+    expect(logSpy).toHaveBeenCalledWith('✓ good updated');
+  });
+
+  it('all=true propagates verbose flag into installSkill options', async () => {
+    writeConfig({ foo: { version: '1.0.0' } });
+    const { updateSkill } = require('../update-skill');
+    const result = await updateSkill(null, { all: true, verbose: true });
+    expect(result).toBe(0);
+    expect(installSkillMock).toHaveBeenCalledWith('foo', {
+      force: true,
+      verbose: true,
+    });
+  });
+
+  // ----- single skill mode -----
+
+  it('updateSkill(name) calls installSkill and returns its result (0=success)', async () => {
+    writeConfig({ foo: { version: '1.0.0' } });
+    const { updateSkill } = require('../update-skill');
+    const result = await updateSkill('foo');
+    expect(result).toBe(0);
+    expect(installSkillMock).toHaveBeenCalledWith('foo', {
+      force: true,
+      verbose: false,
+    });
+    expect(logSpy).toHaveBeenCalledWith('Updating foo...');
+    expect(logSpy).toHaveBeenCalledWith('✓ foo updated');
+  });
+
+  it('updateSkill(name) returns installSkill result when non-zero (no success log)', async () => {
+    writeConfig({ foo: { version: '1.0.0' } });
+    installSkillMock.mockResolvedValue(2);
+    const { updateSkill } = require('../update-skill');
+    const result = await updateSkill('foo');
+    expect(result).toBe(2);
+    expect(logSpy).not.toHaveBeenCalledWith('✓ foo updated');
+  });
+
+  it('removes existing targetDir before invoking installSkill', async () => {
+    writeConfig({ foo: { version: '1.0.0' } });
+    const dir = makeSkillDir('foo');
+    expect(fs.existsSync(dir)).toBe(true);
+
+    let dirExistedDuringInstall = true;
+    installSkillMock.mockImplementation(async () => {
+      dirExistedDuringInstall = fs.existsSync(dir);
+      return 0;
+    });
+
+    const { updateSkill } = require('../update-skill');
+    const result = await updateSkill('foo');
+    expect(result).toBe(0);
+    expect(dirExistedDuringInstall).toBe(false); // rm'd before installSkill called
+  });
+
+  it('does not crash when targetDir does not exist', async () => {
+    writeConfig({ foo: { version: '1.0.0' } });
+    // No skill dir on disk
+    const { updateSkill } = require('../update-skill');
+    const result = await updateSkill('foo');
+    expect(result).toBe(0);
+    expect(installSkillMock).toHaveBeenCalled();
+  });
+
+  // ----- getConfig fallback paths -----
+
+  it('getConfig returns {} when config file does not exist (single-name path → not installed)', async () => {
+    // exercised via "is not installed" — config absent ⇒ installedSkills undefined ⇒ {}
+    const { updateSkill } = require('../update-skill');
+    const result = await updateSkill('anything');
+    expect(result).toBe(1);
+    expect(errorSpy).toHaveBeenCalledWith('Error: anything is not installed');
+  });
+
+  it('getConfig returns {} on JSON parse error (catch swallows)', async () => {
+    fs.mkdirSync(configDir(), { recursive: true });
+    fs.writeFileSync(path.join(configDir(), 'xp-gate.json'), '{not valid json');
+    const { updateSkill } = require('../update-skill');
+    const result = await updateSkill('foo');
+    expect(result).toBe(1);
+    expect(errorSpy).toHaveBeenCalledWith('Error: foo is not installed');
+  });
+
+  it('getConfig parses valid config (single-name path succeeds)', async () => {
+    writeConfig({ foo: { version: '1.0.0' } });
+    const { updateSkill } = require('../update-skill');
+    const result = await updateSkill('foo');
+    expect(result).toBe(0);
+    expect(installSkillMock).toHaveBeenCalledWith('foo', {
+      force: true,
+      verbose: false,
+    });
+  });
+});

package/lib/detect-deps.js

@@ -0,0 +1,157 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { execSync } = require('child_process');
+
+/**
+ * Resolve the user's home directory cross-platform.
+ * Fallback chain: HOME → USERPROFILE → os.homedir()
+ * This covers all known Windows/Linux/macOS/edge cases.
+ */
+const HOME = process.env.HOME || process.env.USERPROFILE || os.homedir();
+
+const SKILLS_DIR = path.join(HOME, '.config', 'opencode', 'skills');
+const OPENCODE_DIR = path.join(HOME, '.config', 'opencode');
+
+const REQUIRED_DEPS = [
+  { name: 'superpowers', minVersion: '1.0.0' },
+  { name: 'gstack', minVersion: '1.0.0' }
+];
+
+/**
+ * Check if bash is available on the system.
+ * XP-Gate hooks are bash scripts — Windows users need Git Bash installed.
+ * @returns {{ok: boolean, path?: string, message?: string}}
+ */
+function checkBash() {
+  try {
+    // Try 'bash' first (works on Linux/macOS and when Git Bash is in PATH)
+    const result = execSync('bash --version', {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe']
+    });
+    const versionMatch = result.match(/version\s+([^\s]+)/);
+    return {
+      ok: true,
+      path: 'bash',
+      version: versionMatch ? versionMatch[1] : 'unknown'
+    };
+  } catch (e) {
+    // On Windows with Git Bash, try common locations
+    const bashPaths = [
+      // Git for Windows
+      'C:\\Program Files\\Git\\bin\\bash.exe',
+      'C:\\Program Files\\Git\\usr\\bin\\bash.exe',
+      'C:\\Program Files (x86)\\Git\\bin\\bash.exe',
+      'C:\\Program Files (x86)\\Git\\usr\\bin\\bash.exe',
+      // MSYS2
+      'C:\\msys64\\usr\\bin\\bash.exe',
+      // Cygwin
+      'C:\\cygwin64\\bin\\bash.exe',
+    ];
+
+    for (const bashPath of bashPaths) {
+      try {
+        const result = execSync(`"${bashPath}" --version`, {
+          encoding: 'utf8',
+          stdio: ['ignore', 'pipe', 'pipe']
+        });
+        const versionMatch = result.match(/version\s+([^\s]+)/);
+        return {
+          ok: true,
+          path: bashPath,
+          version: versionMatch ? versionMatch[1] : 'unknown'
+        };
+      } catch {
+        // Try next path
+      }
+    }
+
+    // Windows-specific guidance
+    if (process.platform === 'win32') {
+      return {
+        ok: false,
+        message: 'bash not found. Windows users must install [Git for Windows](https://git-scm.com/download/win).\n' +
+          '   During installation, ensure "Git Bash Here" is checked — this adds bash.exe to PATH.\n' +
+          '   After installation, restart your terminal and run `npm install` again.'
+      };
+    }
+
+    return {
+      ok: false,
+      message: 'bash not found. Please install bash and ensure it is in PATH.'
+    };
+  }
+}
+
+async function checkDeps() {
+  for (const dep of REQUIRED_DEPS) {
+    const possiblePaths = [
+      path.join(SKILLS_DIR, dep.name),
+      path.join(OPENCODE_DIR, dep.name)
+    ];
+    
+    let depDir = null;
+    for (const p of possiblePaths) {
+      if (fs.existsSync(p)) {
+        depDir = p;
+        break;
+      }
+    }
+    
+    if (!depDir) {
+      return { ok: false, missing: dep.name };
+    }
+    
+    const version = await getSkillVersion(depDir);
+    if (version && compareVersions(version, dep.minVersion) < 0) {
+      return {
+        ok: false,
+        versionMismatch: {
+          name: dep.name,
+          required: dep.minVersion,
+          found: version
+        }
+      };
+    }
+  }
+  
+  return { ok: true };
+}
+
+async function getSkillVersion(skillDir) {
+  const pkgFile = path.join(skillDir, 'package.json');
+  if (fs.existsSync(pkgFile)) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(pkgFile, 'utf8'));
+      return pkg.version;
+    } catch {}
+  }
+  
+  const skillFile = path.join(skillDir, 'SKILL.md');
+  if (fs.existsSync(skillFile)) {
+    const content = fs.readFileSync(skillFile, 'utf8');
+    const versionMatch = content.match(/^version:\s*"?([0-9]+\.[0-9]+\.[0-9]+)"?/m);
+    if (versionMatch) {
+      return versionMatch[1];
+    }
+  }
+  
+  return null;
+}
+
+function compareVersions(a, b) {
+  const partsA = a.split('.').map(Number);
+  const partsB = b.split('.').map(Number);
+  
+  for (let i = 0; i < 3; i++) {
+    const partA = partsA[i] || 0;
+    const partB = partsB[i] || 0;
+    if (partA > partB) return 1;
+    if (partA < partB) return -1;
+  }
+  
+  return 0;
+}
+
+module.exports = { checkDeps, checkBash };