xp-gate 0.5.1

package/lib/rollback.js

@@ -0,0 +1,78 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// Cross-platform home directory resolution
+const HOME = process.env.HOME || process.env.USERPROFILE || os.homedir();
+
+const CONFIG_DIR = path.join(HOME, '.config', 'xp-gate');
+const BACKUP_DIR = path.join(CONFIG_DIR, 'backup');
+const SKILLS_DIR = path.join(HOME, '.config', 'opencode', 'skills');
+
+async function rollback(installId) {
+  const backupDir = path.join(BACKUP_DIR, installId);
+  
+  if (!fs.existsSync(backupDir)) {
+    return;
+  }
+  
+  console.log('Rolling back...');
+  
+  const entries = fs.readdirSync(backupDir);
+  for (const entry of entries) {
+    const src = path.join(backupDir, entry);
+    const dest = path.join(SKILLS_DIR, entry);
+    
+    if (fs.existsSync(src)) {
+      if (fs.existsSync(dest)) {
+        fs.rmSync(dest, { recursive: true });
+      }
+      fs.renameSync(src, dest);
+    }
+  }
+  
+  fs.rmSync(backupDir, { recursive: true });
+  
+  console.log('Rollback complete');
+}
+
+async function createBackup(installId, skillName) {
+  const backupDir = path.join(BACKUP_DIR, installId);
+  const targetDir = path.join(SKILLS_DIR, skillName);
+  
+  if (!fs.existsSync(targetDir)) {
+    return null;
+  }
+  
+  fs.mkdirSync(backupDir, { recursive: true });
+  
+  copyDirRecursive(targetDir, backupDir);
+  
+  return backupDir;
+}
+
+function copyDirRecursive(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+  
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    
+    if (entry.isDirectory()) {
+      copyDirRecursive(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+function cleanupBackup(installId) {
+  const backupDir = path.join(BACKUP_DIR, installId);
+  
+  if (fs.existsSync(backupDir)) {
+    fs.rmSync(backupDir, { recursive: true });
+  }
+}
+
+module.exports = { rollback, createBackup, cleanupBackup };

package/lib/ui-detector.ts

@@ -0,0 +1,99 @@
+import { execSync } from 'child_process';
+
+export interface UiDetectionResult {
+  isUiSprint: boolean;
+  matchedFiles: string[];
+  matchedRules: string[];
+}
+
+const TEMPLATE_EXTENSIONS = ['.njk', '.html', '.ejs', '.hbs'];
+const COMPONENT_EXTENSIONS = ['.tsx', '.vue', '.svelte', '.jsx'];
+const STYLE_EXTENSIONS = ['.css', '.scss', '.sass', '.less'];
+const UI_PATH_PATTERNS = [
+  'views/',
+  'templates/',
+  'components/',
+  'pages/',
+  'src/views/',
+  'src/components/',
+  'src/pages/',
+];
+
+export function detectUiSprint(baseBranch: string = 'main'): UiDetectionResult {
+  try {
+    const files = getChangedFiles(baseBranch);
+    if (files.length === 0) {
+      return { isUiSprint: false, matchedFiles: [], matchedRules: [] };
+    }
+    return collectUiMatches(files);
+  } catch {
+    return { isUiSprint: false, matchedFiles: [], matchedRules: [] };
+  }
+}
+
+export function getChangedFiles(baseBranch: string): string[] {
+  const diffOutput = execSync(`git diff --name-only ${baseBranch}..HEAD`, {
+    encoding: 'utf8',
+    stdio: ['pipe', 'pipe', 'pipe'],
+  }).trim();
+
+  if (diffOutput === '') {
+    return [];
+  }
+
+  return diffOutput
+    .split('\n')
+    .filter((f) => f.length > 0)
+    .map(parseRenamedFile);
+}
+
+export function parseRenamedFile(file: string): string {
+  return file.includes('→') ? file.split('→')[1].trim() : file;
+}
+
+export function collectUiMatches(files: string[]): UiDetectionResult {
+  const matchedFiles: string[] = [];
+  const matchedRules = new Set<string>();
+
+  for (const filePath of files) {
+    const rules = getFileMatchRules(filePath);
+    if (rules.length > 0) {
+      matchedFiles.push(filePath);
+      rules.forEach((r) => matchedRules.add(r));
+    }
+  }
+
+  return {
+    isUiSprint: matchedFiles.length > 0,
+    matchedFiles,
+    matchedRules: Array.from(matchedRules),
+  };
+}
+
+export function getFileMatchRules(filePath: string): string[] {
+  const ext = getFileExtension(filePath);
+  const normalizedPath = filePath.toLowerCase();
+
+  if (TEMPLATE_EXTENSIONS.includes(ext)) {
+    return [`template-${ext}`];
+  }
+
+  if (COMPONENT_EXTENSIONS.includes(ext) && hasUiPathPattern(normalizedPath)) {
+    return [`component-${ext}`];
+  }
+
+  if (STYLE_EXTENSIONS.includes(ext) && hasUiPathPattern(normalizedPath)) {
+    return [`style-${ext}`];
+  }
+
+  return [];
+}
+
+export function getFileExtension(filePath: string): string {
+  const lastDot = filePath.lastIndexOf('.');
+  return lastDot >= 0 ? filePath.slice(lastDot) : '';
+}
+
+export function hasUiPathPattern(normalizedPath: string): boolean {
+  return UI_PATH_PATTERNS.some((pattern) => normalizedPath.includes(pattern));
+}

package/lib/uninstall-skill.js

@@ -0,0 +1,69 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// Cross-platform home directory resolution
+const HOME = process.env.HOME || process.env.USERPROFILE || os.homedir();
+
+const CONFIG_DIR = path.join(HOME, '.config', 'xp-gate');
+const CACHE_DIR = path.join(CONFIG_DIR, 'cache');
+const SKILLS_DIR = path.join(HOME, '.config', 'opencode', 'skills');
+
+async function uninstallSkill(name, options = {}) {
+  const { force = false } = options;
+  
+  if (!name) {
+    console.error('Error: Skill name required');
+    console.error('Usage: xp-gate uninstall-skill <name> [--force]');
+    return 1;
+  }
+  
+  const targetDir = path.join(SKILLS_DIR, name);
+  
+  if (!fs.existsSync(targetDir)) {
+    console.error(`Error: ${name} is not installed`);
+    return 1;
+  }
+  
+  if (!force) {
+    console.log(`Uninstall ${name}? This will remove ${targetDir}`);
+    console.log('Use --force to skip confirmation');
+    return 0;
+  }
+  
+  console.log(`Removing ${name}...`);
+  
+  fs.rmSync(targetDir, { recursive: true });
+  
+  const cacheFile = path.join(CACHE_DIR, `${name}.tgz`);
+  if (fs.existsSync(cacheFile)) {
+    fs.unlinkSync(cacheFile);
+  }
+  
+  const config = getConfig();
+  if (config.installedSkills) {
+    delete config.installedSkills[name];
+    saveConfig(config);
+  }
+  
+  console.log(`✓ ${name} uninstalled`);
+  
+  return 0;
+}
+
+function getConfig() {
+  const configFile = path.join(CONFIG_DIR, 'xp-gate.json');
+  if (fs.existsSync(configFile)) {
+    try {
+      return JSON.parse(fs.readFileSync(configFile, 'utf8'));
+    } catch {}
+  }
+  return {};
+}
+
+function saveConfig(config) {
+  const configFile = path.join(CONFIG_DIR, 'xp-gate.json');
+  fs.writeFileSync(configFile, JSON.stringify(config, null, 2));
+}
+
+module.exports = { uninstallSkill };

package/lib/uninstall.js

@@ -0,0 +1,401 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const crypto = require('crypto');
+
+// Cross-platform home directory resolution
+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');
+const BACKUP_DIR = path.join(CONFIG_DIR, '.uninstall-backup');
+
+/**
+ * Signature strings used to verify file ownership.
+ * Each hook/adapter file contains a unique marker string.
+ */
+const SIGNATURES = {
+  'pre-commit': 'OpenCode Quality Gates - Pre-Commit Hook',
+  'pre-push': 'Pre-push Hook - Code Walkthrough Result Validator',
+  'adapter-common.sh': 'detect_project_lang()'
+};
+
+function isXpGateFile(filePath, signature) {
+  if (!fs.existsSync(filePath)) return false;
+  try {
+    const content = fs.readFileSync(filePath, 'utf8');
+    return content.includes(signature);
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Verify file ownership using manifest sha256 first, then fall back to signature.
+ * Returns true if the file belongs to xp-gate (by either method).
+ */
+function verifyFileOwnership(filePath, manifestEntry, signature) {
+  if (!fs.existsSync(filePath)) return false;
+
+  // Level 1: manifest sha256 check
+  if (manifestEntry && manifestEntry.sha256) {
+    try {
+      const content = fs.readFileSync(filePath);
+      const actualSha256 = crypto.createHash('sha256').update(content).digest('hex');
+      if (actualSha256 === manifestEntry.sha256) {
+        return true; // Exact sha256 match
+      }
+      console.warn(`  Warning: sha256 mismatch for ${path.basename(filePath)}, falling back to signature check`);
+    } catch (e) {
+      // Fall through to signature check
+    }
+  }
+
+  // Level 2: signature string fallback
+  return isXpGateFile(filePath, signature);
+}
+
+function getConfig() {
+  if (!fs.existsSync(CONFIG_FILE)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function saveConfig(config) {
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+
+function getGitDir() {
+  try {
+    const { execSync } = require('child_process');
+    return execSync('git rev-parse --git-dir', { encoding: 'utf8' }).trim();
+  } catch {
+    return null;
+  }
+}
+
+function getCurrentHooksPath() {
+  try {
+    const { execSync } = require('child_process');
+    const result = execSync('git config --global core.hooksPath', {
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe']
+    });
+    return result.trim();
+  } catch {
+    return null;
+  }
+}
+
+function unsetHooksPath() {
+  try {
+    const { execSync } = require('child_process');
+    execSync('git config --global --unset core.hooksPath', {
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe']
+    });
+    return true;
+  } catch (e) {
+    console.warn(`  Warning: Could not unset core.hooksPath: ${e.message}`);
+    return false;
+  }
+}
+
+/**
+ * Create a backup snapshot of files/dirs before deletion.
+ */
+function createBackupSnapshot(plan) {
+  // Use a unique backup dir for this uninstall session
+  const sessionBackup = path.join(BACKUP_DIR, `uninstall-${Date.now()}`);
+  fs.mkdirSync(sessionBackup, { recursive: true });
+
+  const backupMeta = { sessionBackup, entries: [] };
+
+  for (const item of plan) {
+    if (!item.path || !fs.existsSync(item.path)) continue;
+
+    const relPath = path.basename(item.path);
+    const destPath = path.join(sessionBackup, relPath);
+
+    try {
+      const stat = fs.statSync(item.path);
+      if (stat.isDirectory()) {
+        copyDirSync(item.path, destPath);
+      } else {
+        fs.copyFileSync(item.path, destPath);
+      }
+      backupMeta.entries.push({ rel: relPath, original: item.path });
+    } catch (e) {
+      console.warn(`  Warning: Could not backup ${item.path}: ${e.message}`);
+    }
+  }
+
+  return backupMeta;
+}
+
+function copyDirSync(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDirSync(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+function cleanupBackup(backupMeta) {
+  if (!backupMeta || !backupMeta.sessionBackup) return;
+  try {
+    fs.rmSync(backupMeta.sessionBackup, { recursive: true, force: true });
+    // Remove parent backup dir if empty
+    try {
+      const parent = path.dirname(backupMeta.sessionBackup);
+      if (fs.existsSync(parent) && fs.readdirSync(parent).length === 0) {
+        fs.rmdirSync(parent);
+      }
+    } catch {
+      // Ignore cleanup failures
+    }
+  } catch {
+    // Ignore cleanup failures
+  }
+}
+
+/**
+ * Build the uninstall plan based on mode.
+ * Returns an array of operation objects: { type, path, signature, label, critical }
+ */
+function buildPlan(mode) {
+  const plan = [];
+  const manifest = getConfig() && getConfig().manifest ? getConfig().manifest : null;
+
+  if (mode === 'local') {
+    const gitDir = getGitDir();
+    if (gitDir) {
+      const projectRoot = path.dirname(gitDir);
+      const hooksDir = path.join(projectRoot, '.git', 'hooks');
+      const githooksDir = path.join(projectRoot, 'githooks');
+
+      plan.push({
+        type: 'file',
+        path: path.join(hooksDir, 'pre-commit'),
+        signature: SIGNATURES['pre-commit'],
+        label: '.git/hooks/pre-commit',
+        manifestKey: '.git/hooks/pre-commit',
+        critical: true
+      });
+      plan.push({
+        type: 'file',
+        path: path.join(hooksDir, 'pre-push'),
+        signature: SIGNATURES['pre-push'],
+        label: '.git/hooks/pre-push',
+        manifestKey: '.git/hooks/pre-push',
+        critical: true
+      });
+      plan.push({
+        type: 'file',
+        path: path.join(githooksDir, 'adapter-common.sh'),
+        signature: SIGNATURES['adapter-common.sh'],
+        label: 'githooks/adapter-common.sh',
+        manifestKey: 'githooks/adapter-common.sh',
+        critical: true
+      });
+      const adaptersDir = path.join(githooksDir, 'adapters');
+      if (fs.existsSync(adaptersDir)) {
+        plan.push({
+          type: 'dir',
+          path: adaptersDir,
+          label: 'githooks/adapters/',
+          critical: true
+        });
+      }
+    }
+  }
+
+  if (mode === 'global') {
+    plan.push({
+      type: 'gitconfig',
+      action: 'unset-hooks-path',
+      expectedPath: GLOBAL_HOOKS_DIR,
+      label: 'git config --global core.hooksPath',
+      critical: true
+    });
+    if (fs.existsSync(GLOBAL_HOOKS_DIR)) {
+      plan.push({
+        type: 'dir',
+        path: GLOBAL_HOOKS_DIR,
+        label: '~/.config/xp-gate/hooks/',
+        critical: true
+      });
+    }
+    if (fs.existsSync(GLOBAL_ADAPTERS_DIR)) {
+      plan.push({
+        type: 'dir',
+        path: GLOBAL_ADAPTERS_DIR,
+        label: '~/.config/xp-gate/adapters/',
+        critical: true
+      });
+    }
+  }
+
+  // Template dir is common to both modes
+  if (fs.existsSync(TEMPLATE_DIR)) {
+    plan.push({
+      type: 'dir',
+      path: TEMPLATE_DIR,
+      label: '~/.config/opencode/git-hooks-template/',
+      critical: true
+    });
+  }
+
+  return plan;
+}
+
+/**
+ * @param {string[]} args CLI arguments
+ * @returns {number} exit code (0 = success, 1 = error)
+ */
+async function uninstall(args) {
+  const options = {
+    dryRun: args.includes('--dry-run'),
+    force: args.includes('--force'),
+    forceLocal: args.includes('--local'),
+    forceGlobal: args.includes('--global')
+  };
+
+  // §4.3 Step 1: Read config
+  const config = getConfig();
+
+  // §4.3 Step 1: No config → exit cleanly (AC-09 idempotency)
+  if (!config) {
+    console.log('No xp-gate installation found');
+    return 0;
+  }
+
+  // §4.3 Step 1: Already uninstalled → exit cleanly (AC-09 idempotency)
+  if (config.mode === 'uninstalled') {
+    console.log('No xp-gate installation found');
+    return 0;
+  }
+
+  // §4.3 Step 2: Determine mode
+  let mode = config.mode;
+  if (options.forceLocal) mode = 'local';
+  if (options.forceGlobal) mode = 'global';
+
+  if (mode !== 'local' && mode !== 'global') {
+    console.log('No xp-gate installation found');
+    return 0;
+  }
+
+  // §4.3 Step 3: Build uninstall plan
+  const plan = buildPlan(mode);
+
+  if (plan.length === 0) {
+    console.log('Nothing to uninstall');
+    // Still update config to uninstalled
+    saveConfig({ ...config, mode: 'uninstalled', uninstalled: new Date().toISOString() });
+    return 0;
+  }
+
+  // §4.3 Step 4: Print plan
+  console.log(`XP-Gate Uninstall (${mode} mode)`);
+  console.log('=======================\n');
+  console.log('The following will be removed:\n');
+
+  for (const item of plan) {
+    console.log(`  • ${item.label}`);
+  }
+
+  // §4.3 Step 5: Dry-run → exit
+  if (options.dryRun) {
+    console.log('\nDry-run mode — no files were modified');
+    return 0;
+  }
+
+  // §4.3 Step 6: Confirm
+  // Skipped in test environment since we use --force or non-interactive
+  // In real usage with TTY, would prompt here
+
+  // §4.8 State machine: active → uninstalling
+  saveConfig({ ...config, mode: 'uninstalling' });
+
+  // §4.12 Step 4: Create backup snapshot before destructive operations
+  const backupMeta = createBackupSnapshot(plan);
+
+  // §4.12 Execute operations in order (non-destructive first, then destructive)
+  let hadErrors = false;
+
+  for (const item of plan) {
+    try {
+      if (item.type === 'file') {
+        const manifestEntry = config.manifest && config.manifest.files
+          ? config.manifest.files[item.manifestKey]
+          : null;
+
+        if (!verifyFileOwnership(item.path, manifestEntry, item.signature)) {
+          if (fs.existsSync(item.path)) {
+            console.warn(`  Warning: ${item.label} does not contain xp-gate signature — skipping`);
+          }
+          continue;
+        }
+
+        fs.unlinkSync(item.path);
+        console.log(`  Removed ${item.label}`);
+      } else if (item.type === 'dir') {
+        if (fs.existsSync(item.path)) {
+          fs.rmSync(item.path, { recursive: true, force: true });
+          console.log(`  Removed ${item.label}`);
+        }
+      } else if (item.type === 'gitconfig' && item.action === 'unset-hooks-path') {
+        const currentPath = getCurrentHooksPath();
+        if (currentPath === null || currentPath === '') {
+          // Already unset
+          console.log(`  ${item.label} — not set`);
+        } else if (currentPath === item.expectedPath) {
+          unsetHooksPath();
+          console.log(`  Unset ${item.label}`);
+        } else {
+          console.warn(`  Warning: core.hooksPath (${currentPath}) does not match xp-gate path — skipping unset`);
+        }
+      }
+    } catch (e) {
+      console.warn(`  Warning: Could not remove ${item.label}: ${e.message}`);
+      hadErrors = true;
+    }
+  }
+
+  // §4.8 State machine: uninstalling → uninstalled
+  saveConfig({
+    ...getConfig() || config,
+    mode: 'uninstalled',
+    uninstalled: new Date().toISOString(),
+    // Clean up manifest after successful uninstall
+    manifest: undefined
+  });
+
+  // §4.12 Step 11: Clean up backup on success
+  if (!hadErrors) {
+    cleanupBackup(backupMeta);
+  }
+
+  // Print summary
+  console.log('\nUninstall complete');
+  if (hadErrors) {
+    console.log('Some items could not be removed. Run doctor for diagnostics.');
+  }
+
+  return 0;
+}
+
+module.exports = { uninstall, isXpGateFile, SIGNATURES };