@boyingliu01/xp-gate 0.8.6 → 0.8.8

package/lib/__tests__/doctor.test.js

@@ -446,4 +446,147 @@ describe('doctor', () => {
       expect.stringContaining('Not found')
     );
   });
+
+  // === Issue #186: Version mismatch detection ===
+
+  it('detects version mismatch when config version differs from package version', async () => {
+    setupLocalInstall();
+    // Write config with old version
+    const cfg = JSON.parse(fs.readFileSync(configFile(), 'utf8'));
+    cfg.version = '0.3.1.1';
+    fs.writeFileSync(configFile(), JSON.stringify(cfg, null, 2));
+    mockExecSuccess();
+    const { doctor } = require('../doctor');
+
+    const result = await doctor([]);
+
+    expect(result).toBe(1);
+    expect(logSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Version mismatch')
+    );
+    expect(logSpy).toHaveBeenCalledWith(
+      expect.stringContaining('0.3.1.1')
+    );
+  });
+
+  it('passes version check when config version matches package version', async () => {
+    setupLocalInstall();
+    // Write config with matching version
+    const pkg = JSON.parse(fs.readFileSync(
+      path.join(path.dirname(path.dirname(require.resolve('../doctor'))), 'package.json'), 'utf8'
+    ));
+    const cfg = JSON.parse(fs.readFileSync(configFile(), 'utf8'));
+    cfg.version = pkg.version;
+    fs.writeFileSync(configFile(), JSON.stringify(cfg, null, 2));
+    mockExecSuccess();
+    const { doctor } = require('../doctor');
+
+    const result = await doctor([]);
+
+    expect(result).toBe(0);
+    expect(logSpy).toHaveBeenCalledWith(
+      expect.stringContaining('All checks passed')
+    );
+  });
+
+  it('passes version check when config has no version field (legacy)', async () => {
+    setupLocalInstall();
+    // Config without version field — legacy install, should not fail
+    mockExecSuccess();
+    const { doctor } = require('../doctor');
+
+    const result = await doctor([]);
+
+    expect(result).toBe(0);
+    expect(logSpy).toHaveBeenCalledWith(
+      expect.stringContaining('All checks passed')
+    );
+  });
+
+  // === Issue #188: templateDir validation ===
+
+  it('detects templateDir pointing to wrong platform directory', async () => {
+    setupLocalInstall();
+    // Write config with stale opencode templateDir when qoder is active
+    const cfg = JSON.parse(fs.readFileSync(configFile(), 'utf8'));
+    cfg.templateDir = path.join(tmpHome, '.config', 'opencode', 'git-hooks-template');
+    fs.writeFileSync(configFile(), JSON.stringify(cfg, null, 2));
+
+    // Create qoder marker to simulate qoder environment
+    fs.mkdirSync(path.join(tmpHome, '.qoder', 'skills'), { recursive: true });
+
+    // Need fresh module because shared-paths caches detectPlatform at module load
+    delete require.cache[require.resolve('../shared-paths')];
+    delete require.cache[require.resolve('../doctor')];
+    const { doctor: doc2 } = require('../doctor');
+    mockExecSuccess();
+
+    const result = await doc2([]);
+
+    expect(result).toBe(1);
+    expect(logSpy).toHaveBeenCalledWith(
+      expect.stringContaining('templateDir')
+    );
+    expect(logSpy).toHaveBeenCalledWith(
+      expect.stringContaining('opencode')
+    );
+  });
+
+  it('passes templateDir check when templateDir matches current platform', async () => {
+    setupLocalInstall();
+    // Write config with correct qoder templateDir
+    const cfg = JSON.parse(fs.readFileSync(configFile(), 'utf8'));
+    cfg.templateDir = path.join(tmpHome, '.qoder', 'git-hooks-template');
+    fs.writeFileSync(configFile(), JSON.stringify(cfg, null, 2));
+
+    // Create qoder marker
+    fs.mkdirSync(path.join(tmpHome, '.qoder', 'skills'), { recursive: true });
+
+    delete require.cache[require.resolve('../shared-paths')];
+    delete require.cache[require.resolve('../doctor')];
+    const { doctor: doc2 } = require('../doctor');
+    mockExecSuccess();
+
+    const result = await doc2([]);
+
+    expect(result).toBe(0);
+    expect(logSpy).toHaveBeenCalledWith(
+      expect.stringContaining('All checks passed')
+    );
+  });
+
+  it('passes templateDir check when config has no templateDir field (legacy)', async () => {
+    setupLocalInstall();
+    // Config without templateDir — legacy install, should not fail
+    mockExecSuccess();
+    const { doctor } = require('../doctor');
+
+    const result = await doctor([]);
+
+    expect(result).toBe(0);
+    expect(logSpy).toHaveBeenCalledWith(
+      expect.stringContaining('All checks passed')
+    );
+  });
+
+  // === Issue #186: --fix syncs global hooks from package source ===
+
+  it('--fix syncs global hooks when they are outdated', async () => {
+    setupGlobalInstall();
+    // Write an outdated pre-commit hook (different content)
+    const oldContent = '#!/bin/bash\n# OpenCode Quality Gates - Pre-Commit Hook - OLD VERSION\n';
+    fs.writeFileSync(path.join(globalHooksDir(), 'pre-commit'), oldContent);
+    mockExecSuccess();
+    const { doctor } = require('../doctor');
+
+    const result = await doctor(['--fix']);
+
+    expect(result).toBe(0);
+    // Should have restored from package source
+    const restoredContent = fs.readFileSync(path.join(globalHooksDir(), 'pre-commit'), 'utf8');
+    expect(restoredContent).not.toBe(oldContent);
+    expect(logSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Restored')
+    );
+  });
 });

package/lib/__tests__/shared-paths.test.js

@@ -0,0 +1,110 @@
+/**
+ * @test shared-paths
+ * @intent Verify platform-aware template directory resolution
+ * @covers Issue #188 — templateDir pointing to OpenCode residue path
+ */
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+describe('shared-paths', () => {
+  let tmpHome;
+  let originalHome;
+
+  beforeEach(() => {
+    originalHome = process.env.HOME;
+    tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'xpgate-sp-'));
+    process.env.HOME = tmpHome;
+    vi.resetModules();
+    delete require.cache[require.resolve('../shared-paths')];
+  });
+
+  afterEach(() => {
+    process.env.HOME = originalHome;
+    if (tmpHome && fs.existsSync(tmpHome)) {
+      fs.rmSync(tmpHome, { recursive: true, force: true });
+    }
+  });
+
+  function createPlatformMarker(platform) {
+    const dirs = {
+      opencode: path.join(tmpHome, '.config', 'opencode', 'skills'),
+      'claude-code': path.join(tmpHome, '.claude', 'skills'),
+      qoder: path.join(tmpHome, '.qoder', 'skills'),
+    };
+    const dir = dirs[platform];
+    if (dir) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+  }
+
+  it('returns opencode template dir when no platform marker exists (default)', () => {
+    const { TEMPLATE_DIR } = require('../shared-paths');
+    expect(TEMPLATE_DIR).toBe(path.join(tmpHome, '.config', 'opencode', 'git-hooks-template'));
+  });
+
+  it('returns opencode template dir when opencode platform marker exists', () => {
+    createPlatformMarker('opencode');
+    const { TEMPLATE_DIR } = require('../shared-paths');
+    expect(TEMPLATE_DIR).toBe(path.join(tmpHome, '.config', 'opencode', 'git-hooks-template'));
+  });
+
+  it('returns claude-code template dir when claude-code platform marker exists', () => {
+    createPlatformMarker('claude-code');
+    const { TEMPLATE_DIR } = require('../shared-paths');
+    expect(TEMPLATE_DIR).toBe(path.join(tmpHome, '.claude', 'git-hooks-template'));
+  });
+
+  it('returns qoder template dir when qoder platform marker exists', () => {
+    createPlatformMarker('qoder');
+    const { TEMPLATE_DIR } = require('../shared-paths');
+    expect(TEMPLATE_DIR).toBe(path.join(tmpHome, '.qoder', 'git-hooks-template'));
+  });
+
+  it('qoder marker takes priority over opencode when both exist', () => {
+    createPlatformMarker('opencode');
+    createPlatformMarker('qoder');
+    const { TEMPLATE_DIR } = require('../shared-paths');
+    // Qoder should take priority (checked first)
+    expect(TEMPLATE_DIR).toBe(path.join(tmpHome, '.qoder', 'git-hooks-template'));
+  });
+
+  it('detectPlatform returns opencode when no marker exists', () => {
+    const { detectPlatform } = require('../shared-paths');
+    expect(detectPlatform()).toBe('opencode');
+  });
+
+  it('detectPlatform returns qoder when qoder marker exists', () => {
+    createPlatformMarker('qoder');
+    const { detectPlatform } = require('../shared-paths');
+    expect(detectPlatform()).toBe('qoder');
+  });
+
+  it('detectPlatform returns claude-code when claude-code marker exists', () => {
+    createPlatformMarker('claude-code');
+    const { detectPlatform } = require('../shared-paths');
+    expect(detectPlatform()).toBe('claude-code');
+  });
+
+  it('getTemplateDir returns correct path for each platform', () => {
+    const { getTemplateDir } = require('../shared-paths');
+
+    // No marker → opencode
+    expect(getTemplateDir()).toBe(path.join(tmpHome, '.config', 'opencode', 'git-hooks-template'));
+
+    // Qoder marker
+    createPlatformMarker('qoder');
+    // Need fresh module to re-evaluate
+    delete require.cache[require.resolve('../shared-paths')];
+    const { getTemplateDir: getTpl2 } = require('../shared-paths');
+    expect(getTpl2()).toBe(path.join(tmpHome, '.qoder', 'git-hooks-template'));
+  });
+
+  it('CONFIG_DIR and GLOBAL_HOOKS_DIR remain under xp-gate regardless of platform', () => {
+    createPlatformMarker('qoder');
+    const { CONFIG_DIR, GLOBAL_HOOKS_DIR, GLOBAL_ADAPTERS_DIR } = require('../shared-paths');
+    expect(CONFIG_DIR).toBe(path.join(tmpHome, '.config', 'xp-gate'));
+    expect(GLOBAL_HOOKS_DIR).toBe(path.join(tmpHome, '.config', 'xp-gate', 'hooks'));
+    expect(GLOBAL_ADAPTERS_DIR).toBe(path.join(tmpHome, '.config', 'xp-gate', 'adapters'));
+  });
+});

package/lib/doctor.js

@@ -7,11 +7,26 @@ const {
   CONFIG_FILE,
   GLOBAL_HOOKS_DIR,
   GLOBAL_ADAPTERS_DIR,
+  detectPlatform,
+  getTemplateDir,
 } = require('./shared-paths.js');
 
 // npm package source dir (template hooks/adapters)
 const PKG_DIR = path.dirname(__dirname);
 
+/**
+ * Read the package version from the installed package.json.
+ * @returns {string|null}
+ */
+function getPackageVersion() {
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(PKG_DIR, 'package.json'), 'utf8'));
+    return pkg.version || null;
+  } catch {
+    return null;
+  }
+}
+
 /**
  * Signature strings used to verify file ownership.
  */
@@ -40,6 +55,10 @@ function getConfig() {
   }
 }
 
+function saveConfig(config) {
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+
 function getGitDir() {
   try {
     return execSync('git rev-parse --git-dir', { encoding: 'utf8' }).trim();
@@ -190,17 +209,43 @@ function diagnose() {
   checks.push(...configResult.checks);
   issues += configResult.issues;
 
-  // --- Check 2: Hooks files ---
+  // --- Check 2: Version mismatch ---
+  const pkgVersion = getPackageVersion();
+  const configVersion = config.version;
+  if (configVersion && pkgVersion && configVersion !== pkgVersion) {
+    checks.push({
+      name: 'Version mismatch',
+      status: 'FAIL',
+      detail: `config: ${configVersion}, package: ${pkgVersion} — run 'xp-gate doctor --fix' to sync`
+    });
+    issues++;
+  }
+
+  // --- Check 3: templateDir validation ---
+  const configTemplateDir = config.templateDir;
+  if (configTemplateDir) {
+    const expectedTemplateDir = getTemplateDir();
+    if (configTemplateDir !== expectedTemplateDir) {
+      checks.push({
+        name: 'templateDir',
+        status: 'FAIL',
+        detail: `points to ${configTemplateDir}, expected ${expectedTemplateDir} for current platform`
+      });
+      issues++;
+    }
+  }
+
+  // --- Check 4: Hooks files ---
   if (config.mode === 'local') {
     issues += checkLocalHooks(checks);
   } else {
     issues += checkGlobalHooks(checks);
   }
 
-  // --- Check 3: Adapters directory ---
+  // --- Check 5: Adapters directory ---
   issues += checkAdapters(checks, config.mode, getGitDir());
 
-  // --- Check 4: Environment dependencies ---
+  // --- Check 6: Environment dependencies ---
   checkEnv(checks);
 
   return { checks, issues };
@@ -245,6 +290,24 @@ function fixIssues(checks, config) {
   const srcDir = PKG_DIR;
   let fixed = false;
 
+  // Fix version mismatch — update config version to match package
+  const pkgVersion = getPackageVersion();
+  if (pkgVersion && config.version !== pkgVersion) {
+    config.version = pkgVersion;
+    saveConfig(config);
+    console.log(`  ✓ Updated config version to ${pkgVersion}`);
+    fixed = true;
+  }
+
+  // Fix templateDir mismatch
+  const expectedTemplateDir = getTemplateDir();
+  if (config.templateDir && config.templateDir !== expectedTemplateDir) {
+    config.templateDir = expectedTemplateDir;
+    saveConfig(config);
+    console.log(`  ✓ Updated templateDir to ${expectedTemplateDir}`);
+    fixed = true;
+  }
+
   // Fix missing hooks
   if (config.mode === 'local') {
     const gitDir = getGitDir();

package/lib/shared-paths.js

@@ -4,9 +4,11 @@
  *
  * @intent Eliminate duplicate path constants in init.js / uninstall.js / detect-deps.js
  * @covers Issue #107 — duplicate code between init.js and uninstall.js
+ * @covers Issue #188 — templateDir pointing to OpenCode residue path
  */
 const path = require('path');
 const os = require('os');
+const fs = require('fs');
 
 /**
  * Resolve the user's home directory cross-platform.
@@ -16,10 +18,42 @@ const HOME_DIR = process.env.HOME || process.env.USERPROFILE || os.homedir();
 
 const CONFIG_DIR = path.join(HOME_DIR, '.config', 'xp-gate');
 const CONFIG_FILE = path.join(CONFIG_DIR, 'xp-gate.json');
-const TEMPLATE_DIR = path.join(HOME_DIR, '.config', 'opencode', 'git-hooks-template');
 const GLOBAL_HOOKS_DIR = path.join(CONFIG_DIR, 'hooks');
 const GLOBAL_ADAPTERS_DIR = path.join(CONFIG_DIR, 'adapters');
 
+/**
+ * Detect which AI agent platform is currently in use.
+ * Mirrors detectPlatform() in detect-deps.js to avoid circular deps.
+ * @returns {'opencode' | 'claude-code' | 'qoder'}
+ */
+function detectPlatform() {
+  if (fs.existsSync(path.join(HOME_DIR, '.qoder', 'skills'))) return 'qoder';
+  if (fs.existsSync(path.join(HOME_DIR, '.claude', 'skills'))) return 'claude-code';
+  return 'opencode';
+}
+
+/**
+ * Get the git hooks template directory for the current platform.
+ * Each AI agent platform has its own config directory:
+ *   - opencode:   ~/.config/opencode/git-hooks-template
+ *   - claude-code: ~/.claude/git-hooks-template
+ *   - qoder:      ~/.qoder/git-hooks-template
+ *
+ * This prevents templateDir from pointing to a stale platform's directory
+ * after migrating from one AI agent to another (e.g., OpenCode → Qoder).
+ *
+ * @returns {string} Path to the platform-specific git hooks template directory
+ */
+function getTemplateDir() {
+  const platform = detectPlatform();
+  const configDir = platform === 'claude-code' ? '.claude' :
+                    platform === 'qoder' ? '.qoder' :
+                    path.join('.config', 'opencode');
+  return path.join(HOME_DIR, configDir, 'git-hooks-template');
+}
+
+const TEMPLATE_DIR = getTemplateDir();
+
 module.exports = {
   HOME_DIR,
   CONFIG_DIR,
@@ -27,4 +61,6 @@ module.exports = {
   TEMPLATE_DIR,
   GLOBAL_HOOKS_DIR,
   GLOBAL_ADAPTERS_DIR,
+  detectPlatform,
+  getTemplateDir,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@boyingliu01/xp-gate",
-  "version": "0.8.6",
+  "version": "0.8.8",
   "description": "AI-driven development workflow: 6 quality gates + Delphi review + Sprint Flow",
   "bin": {
     "xp-gate": "./bin/xp-gate.js"

package/plugins/claude-code/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "xp-gate",
-  "version": "0.8.6",
+  "version": "0.8.8",
   "displayName": "XP-Gate",
   "description": "Extreme Programming quality gates + AI workflow skills for Claude Code. Includes 6 quality gates, Sprint Flow, and Delphi multi-expert review.",
   "author": {