xtrm-cli 2.1.4

package/dist/index.d.cts

@@ -0,0 +1,2 @@
+
+export {  }

package/index.js

@@ -0,0 +1,151 @@
+#!/usr/bin/env node
+
+import kleur from 'kleur';
+import minimist from 'minimist';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import prompts from 'prompts';
+import { getContext, resetContext } from './lib/context.js';
+import { calculateDiff } from './lib/diff.js';
+import { executeSync } from './lib/sync.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const repoRoot = path.resolve(__dirname, '..');
+
+const args = minimist(process.argv.slice(2));
+
+function printDetails(title, items, colorFn) {
+    if (items.length > 0) {
+        console.log(colorFn(`\n  ${title}:`));
+        items.forEach(item => console.log(colorFn(`    - ${item}`)));
+    }
+}
+
+async function processTarget(targetDir, syncMode) {
+    console.log(kleur.cyan().bold(`\nTarget: ${targetDir}`));
+    
+    const isClaude = targetDir.includes('.claude') || targetDir.includes('Claude');
+    const isDryRun = !!args['dry-run'];
+
+    if (isDryRun) {
+        console.log(kleur.yellow().bold('  [DRY RUN MODE - No changes will be written to disk]'));
+    }
+
+    // 1. Scan/Diff
+    console.log(kleur.gray('Scanning differences...'));
+    const changeSet = await calculateDiff(repoRoot, targetDir);
+
+    const categories = ['skills', 'hooks', 'config', 'commands'];
+
+    const totalMissing = categories.reduce((sum, cat) => sum + changeSet[cat].missing.length, 0);
+    const totalOutdated = categories.reduce((sum, cat) => sum + changeSet[cat].outdated.length, 0);
+    const totalDrifted = categories.reduce((sum, cat) => sum + changeSet[cat].drifted.length, 0);
+
+    // 2. Display Detailed Breakdown
+    if (totalMissing === 0 && totalOutdated === 0 && totalDrifted === 0) {
+        console.log(kleur.green('System is up to date.'));
+    } else {
+        console.log(kleur.bold('Analysis Results:'));
+        
+        // Missing (Green)
+        const missingItems = [];
+        categories.forEach(cat => {
+            changeSet[cat].missing.forEach(item => {
+                let prefix = cat;
+                if (cat === 'commands') {
+                    prefix = isClaude ? '.claude/commands' : '.gemini/commands';
+                }
+                missingItems.push(`${prefix}/${item}`);
+            });
+        });
+        printDetails('[+] Missing in System (Will be Installed)', missingItems, kleur.green);
+
+        // Outdated (Blue)
+        const outdatedItems = [];
+        categories.forEach(cat => {
+            changeSet[cat].outdated.forEach(item => {
+                let prefix = cat;
+                if (cat === 'commands') {
+                    prefix = isClaude ? '.claude/commands' : '.gemini/commands';
+                }
+                outdatedItems.push(`${prefix}/${item}`);
+            });
+        });
+        printDetails('[^] Outdated in System (Will be Updated)', outdatedItems, kleur.blue);
+
+        // Drifted (Magenta)
+        const driftedItems = [];
+        categories.forEach(cat => {
+            changeSet[cat].drifted.forEach(item => {
+                let prefix = cat;
+                if (cat === 'commands') {
+                    prefix = isClaude ? '.claude/commands' : '.gemini/commands';
+                }
+                driftedItems.push(`${prefix}/${item}`);
+            });
+        });
+        printDetails('[<] Drifted / Locally Modified (Needs Backport or Manual Merge)', driftedItems, kleur.magenta);
+        
+        console.log(''); // spacer
+    }
+
+    // 3. Prompt for Action (Per Target)
+    const actions = [];
+    if (totalMissing > 0 || totalOutdated > 0) {
+        actions.push({ title: 'Sync Repo -> System (Update/Install)', value: 'sync' });
+    }
+    if (totalDrifted > 0) {
+        actions.push({ title: 'Backport System -> Repo (Save local changes)', value: 'backport' });
+    }
+    
+    actions.push({ title: 'Skip this target', value: 'skip' });
+
+    const response = await prompts({
+        type: 'select',
+        name: 'action',
+        message: 'What would you like to do?',
+        choices: actions
+    });
+
+    if (!response.action || response.action === 'skip') {
+        console.log(kleur.gray('Skipping.'));
+        return;
+    }
+
+    // Execute Sync/Backport
+    console.log(kleur.gray('\nExecuting changes...'));
+    const count = await executeSync(repoRoot, targetDir, changeSet, syncMode, response.action, isDryRun);
+    
+    console.log(kleur.green().bold(`\nSuccessfully processed ${count} items.`));
+}
+
+async function main() {
+    console.log(kleur.cyan().bold('\nJaggers Agent Tools - Config Manager'));
+
+    if (args.reset) {
+        resetContext();
+    }
+
+    try {
+        const context = await getContext();
+        
+        console.log(kleur.dim(`\nMode: ${context.syncMode}`));
+        console.log(kleur.dim(`Selected Targets: ${context.targets.length}`));
+
+        for (const target of context.targets) {
+            await processTarget(target, context.syncMode);
+        }
+
+        console.log(kleur.gray('\nAll operations complete. Goodbye!'));
+
+    } catch (err) {
+        if (err.message === 'SIGINT') {
+            console.log(kleur.yellow('\nExited.'));
+        } else {
+            console.error(kleur.red(`\nError: ${err.message}`));
+        }
+        process.exit(1);
+    }
+}
+
+main();

package/lib/atomic-config.js

@@ -0,0 +1,236 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { parse, stringify } from 'comment-json';
+
+/**
+ * Atomic Configuration Handler with Vault Pattern
+ * Ensures safe read/write operations with protection against corruption during crashes
+ */
+
+// Protected keys that should never be overwritten if they exist locally
+const PROTECTED_KEYS = [
+  'permissions.allow',       // User-defined permissions
+  'hooks.UserPromptSubmit',  // Claude hooks
+  'hooks.SessionStart',
+  'hooks.PreToolUse',
+  'hooks.BeforeAgent',       // Gemini hooks
+  'hooks.BeforeTool',        // Gemini hooks
+  'security',                // Auth secrets/OAuth data
+  'general',                 // Personal preferences
+  'enabledPlugins',          // User-enabled/disabled plugins
+  'model',                   // User's preferred model
+  'skillSuggestions.enabled' // User preferences
+];
+
+/**
+ * Get a nested value from an object using dot notation path
+ */
+function getNestedValue(obj, path) {
+  return path.split('.').reduce((current, key) => {
+    return current && current[key] !== undefined ? current[key] : undefined;
+  }, obj);
+}
+
+/**
+ * Set a nested value in an object using dot notation path
+ */
+function setNestedValue(obj, path, value) {
+  const keys = path.split('.');
+  let current = obj;
+  
+  for (let i = 0; i < keys.length - 1; i++) {
+    const key = keys[i];
+    if (!(key in current) || typeof current[key] !== 'object' || current[key] === null) {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+  
+  current[keys[keys.length - 1]] = value;
+}
+
+/**
+ * Check if a key path is exactly protected or a parent of a protected key
+ */
+function isProtectedPath(keyPath) {
+  return PROTECTED_KEYS.some(protectedPath =>
+    keyPath === protectedPath || protectedPath.startsWith(keyPath + '.')
+  );
+}
+
+/**
+ * Check if a key path is a protected key or a child of a protected key
+ */
+function isValueProtected(keyPath) {
+  return PROTECTED_KEYS.some(protectedPath =>
+    keyPath === protectedPath || keyPath.startsWith(protectedPath + '.')
+  );
+}
+
+/**
+ * Deep merge two objects, preserving protected values from the original
+ */
+export function deepMergeWithProtection(original, updates, currentPath = '') {
+  const result = { ...original };
+
+  for (const [key, value] of Object.entries(updates)) {
+    const keyPath = currentPath ? `${currentPath}.${key}` : key;
+
+    // If this specific value is protected and exists locally, skip it
+    if (isValueProtected(keyPath) && original.hasOwnProperty(key)) {
+      continue;
+    }
+
+    // Special handling for mcpServers: merge individual server entries
+    if (key === 'mcpServers' && typeof value === 'object' && value !== null &&
+        typeof original[key] === 'object' && original[key] !== null) {
+      
+      result[key] = { ...original[key] }; // Start with original servers
+
+      // Add servers from updates that don't exist in original
+      for (const [serverName, serverConfig] of Object.entries(value)) {
+        if (!result[key].hasOwnProperty(serverName)) {
+          result[key][serverName] = serverConfig;
+        }
+      }
+    } else if (
+      typeof value === 'object' &&
+      value !== null &&
+      !Array.isArray(value) &&
+      typeof original[key] === 'object' &&
+      original[key] !== null &&
+      !Array.isArray(original[key])
+    ) {
+      // Recursively merge nested objects
+      result[key] = deepMergeWithProtection(original[key], value, keyPath);
+    } else {
+      // Overwrite with new value for non-protected keys
+      result[key] = value;
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Atomically write data to a file using a temporary file
+ */
+export async function atomicWrite(filePath, data, options = {}) {
+  const { 
+    preserveComments = false, 
+    backupOnSuccess = false,
+    backupSuffix = '.bak' 
+  } = options;
+  
+  const tempFilePath = `${filePath}.tmp.${Date.now()}.${Math.random().toString(36).substr(2, 9)}`;
+  
+  try {
+    let content;
+    if (preserveComments) {
+      content = stringify(data, null, 2);
+    } else {
+      content = JSON.stringify(data, null, 2);
+    }
+    
+    await fs.writeFile(tempFilePath, content, 'utf8');
+    
+    const tempStats = await fs.stat(tempFilePath);
+    if (tempStats.size === 0) {
+      throw new Error('Temporary file is empty - write failed');
+    }
+    
+    if (backupOnSuccess && await fs.pathExists(filePath)) {
+      const backupPath = `${filePath}${backupSuffix}`;
+      await fs.copy(filePath, backupPath);
+    }
+    
+    await fs.rename(tempFilePath, filePath);
+  } catch (error) {
+    try {
+      if (await fs.pathExists(tempFilePath)) {
+        await fs.unlink(tempFilePath);
+      }
+    } catch (cleanupError) {}
+    throw error;
+  }
+}
+
+/**
+ * Safely read a JSON configuration file with error handling
+ */
+export async function safeReadConfig(filePath) {
+  try {
+    if (!(await fs.pathExists(filePath))) {
+      return {};
+    }
+    
+    const content = await fs.readFile(filePath, 'utf8');
+    
+    try {
+      return parse(content);
+    } catch (parseError) {
+      return JSON.parse(content);
+    }
+  } catch (error) {
+    if (error.code === 'ENOENT') return {};
+    throw new Error(`Failed to read config file: ${error.message}`);
+  }
+}
+
+/**
+ * Perform a safe merge of repository config with local config
+ */
+export async function safeMergeConfig(localConfigPath, repoConfig, options = {}) {
+  const {
+    preserveComments = true,
+    backupOnSuccess = true,
+    dryRun = false,
+    resolvedLocalConfig = null  // NEW: pre-resolved local config with corrected paths
+  } = options;
+
+  // Use pre-resolved config if provided (fixes hardcoded paths), otherwise read from disk
+  const localConfig = resolvedLocalConfig || await safeReadConfig(localConfigPath);
+  const changes = [];
+
+  // Report MCP Servers preservation
+  if (localConfig.mcpServers && typeof localConfig.mcpServers === 'object') {
+    const localServerNames = Object.keys(localConfig.mcpServers);
+    if (localServerNames.length > 0) {
+      changes.push(`Preserved ${localServerNames.length} local mcpServers: ${localServerNames.join(', ')}`);
+    }
+  }
+
+  // Report new MCP Servers additions
+  if (repoConfig.mcpServers && typeof repoConfig.mcpServers === 'object') {
+    const repoServerNames = Object.keys(repoConfig.mcpServers);
+    const newServerNames = repoServerNames.filter(name =>
+      !localConfig.mcpServers || !localConfig.mcpServers.hasOwnProperty(name)
+    );
+
+    if (newServerNames.length > 0) {
+      changes.push(`Added ${newServerNames.length} new non-conflicting mcpServers from repository: ${newServerNames.join(', ')}`);
+    }
+  }
+
+  // Perform the merge
+  let mergedConfig = deepMergeWithProtection(localConfig, repoConfig);
+
+  // Check if there are any differences
+  const configsAreEqual = JSON.stringify(localConfig) === JSON.stringify(mergedConfig);
+
+  if (!configsAreEqual && !dryRun) {
+    await atomicWrite(localConfigPath, mergedConfig, {
+      preserveComments,
+      backupOnSuccess
+    });
+  }
+
+  return {
+    updated: !configsAreEqual,
+    changes: changes
+  };
+}
+
+export function getProtectedKeys() {
+  return [...PROTECTED_KEYS];
+}

package/lib/config-adapter.js

@@ -0,0 +1,231 @@
+import path from 'path';
+import os from 'os';
+
+export class EnvVarTransformer {
+  static transform(value, from, to) {
+    if (from === to) return value;
+    if (typeof value === "string") return this.transformString(value, from, to);
+    if (Array.isArray(value)) return value.map((item) => this.transform(item, from, to));
+    if (value && typeof value === "object") {
+      const result = {};
+      for (const [key, item] of Object.entries(value)) {
+        result[key] = this.transform(item, from, to);
+      }
+      return result;
+    }
+    return value;
+  }
+
+  static transformString(value, from, to) {
+    const normalized = this.toNormalized(value, from);
+    return this.fromNormalized(normalized, to);
+  }
+
+  static toNormalized(value, from) {
+    switch (from) {
+      case "claude": return value;
+      case "cursor": return value.replace(/\$\{env:([A-Za-z0-9_]+)\}/g, "${$1}");
+      case "opencode": return value.replace(/\{env:([A-Za-z0-9_]+)\}/g, "${$1}");
+      case "gemini": return value; // Gemini uses ${VAR} like Claude
+      case "qwen": return value;   // Qwen uses ${VAR} like Claude
+      default: return value;
+    }
+  }
+
+  static fromNormalized(value, to) {
+    switch (to) {
+      case "claude": return value;
+      case "cursor":
+        return value.replace(/\$\{([A-Z0-9_]+)\}/g, (match, name) => {
+          if (["workspaceFolder", "userHome"].includes(name)) return match;
+          return `\${env:${name}}`;
+        });
+      case "opencode":
+        return value.replace(/\$\{([A-Z0-9_]+)\}/g, "{env:$1}");
+      case "gemini": return value; // Gemini uses ${VAR} like Claude
+      case "qwen": return value;   // Qwen uses ${VAR} like Claude
+      default: return value;
+    }
+  }
+}
+
+export class ConfigAdapter {
+  constructor(systemRoot) {
+    this.systemRoot = systemRoot;
+    this.homeDir = os.homedir();
+    this.isClaude = systemRoot.includes('.claude') || systemRoot.includes('Claude');
+    this.isGemini = systemRoot.includes('.gemini') || systemRoot.includes('Gemini');
+    this.isQwen = systemRoot.includes('.qwen') || systemRoot.includes('Qwen');
+    this.isCursor = systemRoot.toLowerCase().includes('cursor');
+    this.isAntigravity = systemRoot.includes('antigravity');
+
+    this.targetFormat = this.isCursor ? 'cursor' : 
+                        this.isAntigravity ? 'antigravity' :
+                        (this.isClaude ? 'claude' : 'claude');
+    this.hooksDir = path.join(this.systemRoot, 'hooks');
+  }
+
+  adaptMcpConfig(canonicalConfig) {
+    if (!canonicalConfig || !canonicalConfig.mcpServers) return {};
+    const config = JSON.parse(JSON.stringify(canonicalConfig));
+
+    // Transform Env Vars
+    config.mcpServers = EnvVarTransformer.transform(config.mcpServers, 'claude', this.targetFormat);
+
+    // Apply format-specific transformations
+    if (this.isGemini || this.isQwen) {
+      this.transformToGeminiFormat(config.mcpServers);
+    } else if (this.isAntigravity) {
+      this.transformToAntigravityFormat(config.mcpServers);
+    } else if (this.isClaude) {
+      this.transformToClaudeFormat(config.mcpServers);
+    }
+
+    // Resolve Paths
+    this.resolveMcpPaths(config.mcpServers);
+
+    return config;
+  }
+
+  adaptHooksConfig(canonicalHooks) {
+    if (!canonicalHooks) return {};
+    if (this.isCursor) return { hooks: {} }; 
+
+    const hooksConfig = JSON.parse(JSON.stringify(canonicalHooks));
+
+    if (this.isGemini) {
+      return this.transformToGeminiHooks(hooksConfig);
+    }
+
+    this.resolveHookScripts(hooksConfig);
+    return hooksConfig;
+  }
+
+  resolveMcpPaths(servers) {
+    for (const server of Object.values(servers)) {
+      if (server.args) server.args = server.args.map(arg => this.resolvePath(arg));
+      if (server.cwd) server.cwd = this.resolvePath(server.cwd);
+      if (server.env) {
+        for (const key in server.env) server.env[key] = this.resolvePath(server.env[key]);
+      }
+    }
+  }
+
+  /**
+   * Transform canonical MCP config to Gemini/Qwen format
+   * - Remove 'type' field (not used)
+   * - Keep 'url' for HTTP servers
+   * - Keep 'command' and 'args' for stdio servers
+   */
+  transformToGeminiFormat(servers) {
+    for (const server of Object.values(servers)) {
+      // Gemini doesn't use the 'type' field
+      delete server.type;
+    }
+  }
+
+  /**
+   * Transform canonical MCP config to Claude Code format
+   * - Ensure 'type' field is present (stdio/http/sse)
+   * - Keep 'url' for HTTP/SSE servers
+   */
+  transformToClaudeFormat(servers) {
+    for (const server of Object.values(servers)) {
+      // Claude requires 'type' field for non-stdio servers
+      if (server.url && !server.type) {
+        // Determine type from URL pattern
+        if (server.url.includes('/sse')) {
+          server.type = 'sse';
+        } else {
+          server.type = 'http';
+        }
+      } else if (server.command && !server.type) {
+        server.type = 'stdio';
+      }
+    }
+  }
+
+  /**
+   * Transform canonical MCP config to Antigravity format
+   * - Ensure 'type' field is present
+   * - Transform 'url' to 'serverUrl' for HTTP/SSE servers
+   * - Support 'disabled' flag
+   */
+  transformToAntigravityFormat(servers) {
+    for (const [name, server] of Object.entries(servers)) {
+      // Ensure type is set
+      if (server.url && !server.type) {
+        if (server.url.includes('/sse')) {
+          server.type = 'sse';
+        } else {
+          server.type = 'http';
+        }
+      } else if (server.command && !server.type) {
+        server.type = 'stdio';
+      }
+
+      // Transform url → serverUrl for HTTP/SSE servers
+      if (server.url && (server.type === 'http' || server.type === 'sse')) {
+        server.serverUrl = server.url;
+        delete server.url;
+      }
+    }
+  }
+
+  resolveHookScripts(hooksConfig) {
+    if (hooksConfig.hooks) {
+      for (const [event, hooks] of Object.entries(hooksConfig.hooks)) {
+        if (Array.isArray(hooks)) {
+            hooks.forEach(hook => {
+                if (hook.script) {
+                  hook.type = "command";
+                  hook.command = path.join(this.hooksDir, hook.script);
+                  delete hook.script;
+                }
+            });
+        }
+      }
+    }
+    if (hooksConfig.statusLine && hooksConfig.statusLine.script) {
+        hooksConfig.statusLine.type = "command";
+        hooksConfig.statusLine.command = path.join(this.hooksDir, hooksConfig.statusLine.script);
+        delete hooksConfig.statusLine.script;
+    }
+  }
+
+  transformToGeminiHooks(hooksConfig) {
+    const geminiHooks = { hooks: {} };
+    const eventMap = {
+      'UserPromptSubmit': 'BeforeAgent',
+      'PreToolUse': 'BeforeTool',
+      'SessionStart': 'SessionStart'
+    };
+    const toolMap = { 'Read': 'read_file', 'Write': 'write_file', 'Edit': 'replace', 'Bash': 'run_shell_command' };
+
+    for (const [event, hooks] of Object.entries(hooksConfig.hooks)) {
+      const geminiEvent = eventMap[event];
+      if (!geminiEvent) continue;
+      geminiHooks.hooks[geminiEvent] = hooks.map(hook => {
+          const newHook = { ...hook };
+          if (newHook.matcher) {
+             for (const [claudeTool, geminiTool] of Object.entries(toolMap)) {
+                 newHook.matcher = newHook.matcher.replace(new RegExp(`\\b${claudeTool}\\b`, 'g'), geminiTool);
+             }
+          }
+          if (newHook.script) {
+             newHook.type = "command";
+             newHook.command = path.join(this.hooksDir, newHook.script);
+             delete newHook.script;
+          }
+          newHook.timeout = newHook.timeout || 60000;
+          return newHook;
+      });
+    }
+    return geminiHooks;
+  }
+
+  resolvePath(p) {
+    if (!p || typeof p !== 'string') return p;
+    return p.replace(/~\//g, this.homeDir + '/').replace(/\${HOME}/g, this.homeDir);
+  }
+}

package/lib/config-injector.js

@@ -0,0 +1,80 @@
+import path from 'path';
+import fs from 'fs-extra';
+import { parse, assign, stringify } from 'comment-json';
+import kleur from 'kleur';
+
+/**
+ * Safely inject hook configuration into settings.json
+ */
+export async function injectHookConfig(targetDir, repoRoot) {
+    const settingsPath = path.join(targetDir, 'settings.json');
+    
+    if (!fs.existsSync(settingsPath)) {
+        console.log(kleur.yellow(`  [!] settings.json not found in ${targetDir}. Skipping auto-config.`));
+        return false;
+    }
+
+    try {
+        const rawContent = await fs.readFile(settingsPath, 'utf8');
+        const settings = parse(rawContent);
+
+        if (!settings || typeof settings !== 'object' || Array.isArray(settings)) {
+            console.log(kleur.yellow(`  [!] settings.json is not a valid object. Skipping auto-config.`));
+            return false;
+        }
+
+        // Define our required hooks
+        const requiredHooks = [
+            {
+                name: "skill-suggestion",
+                path: path.join(targetDir, 'hooks', 'skill-suggestion.sh'),
+                events: ["userPromptSubmit"]
+            },
+            {
+                name: "serena-workflow-reminder",
+                path: path.join(targetDir, 'hooks', 'serena-workflow-reminder.sh'),
+                events: ["toolUse"]
+            }
+        ];
+
+        let modified = false;
+
+        if (!Array.isArray(settings.hooks)) {
+            settings.hooks = [];
+            modified = true;
+        }
+
+        for (const req of requiredHooks) {
+            const exists = settings.hooks.find(h => h.name === req.name || h.path === req.path);
+            
+            if (!exists) {
+                console.log(kleur.blue(`  [+] Adding hook: ${req.name}`));
+                settings.hooks.push(req);
+                modified = true;
+            } else {
+                // Optional: Update path if it changed
+                if (exists.path !== req.path) {
+                    console.log(kleur.blue(`  [^] Updating hook path: ${req.name}`));
+                    exists.path = req.path;
+                    modified = true;
+                }
+            }
+        }
+
+        if (modified) {
+            // Backup
+            const backupPath = `${settingsPath}.bak`;
+            await fs.copy(settingsPath, backupPath);
+            console.log(kleur.gray(`  [i] Backup created at settings.json.bak`));
+
+            // Write back with comments preserved
+            await fs.writeFile(settingsPath, stringify(settings, null, 2));
+            return true;
+        }
+
+        return false;
+    } catch (err) {
+        console.error(kleur.red(`  [!] Error parsing settings.json: ${err.message}`));
+        return false;
+    }
+}