xtrm-cli 2.1.4

package/lib/context.js

@@ -0,0 +1,73 @@
+import os from 'os';
+import path from 'path';
+import fs from 'fs-extra';
+import Conf from 'conf';
+import prompts from 'prompts';
+import kleur from 'kleur';
+
+// Initialize configuration (persists sync mode preference only)
+const config = new Conf({
+    projectName: 'jaggers-config-manager',
+    defaults: {
+        syncMode: 'copy' // 'copy' or 'symlink'
+    }
+});
+
+// Define known paths including user requested ones
+const CANDIDATE_PATHS = [
+    { label: '.claude', path: path.join(os.homedir(), '.claude') },
+    { label: '.gemini', path: path.join(os.homedir(), '.gemini') },
+    { label: '.qwen', path: path.join(os.homedir(), '.qwen') },
+    { label: '~/.gemini/antigravity', path: path.join(os.homedir(), '.gemini', 'antigravity') },
+    // Standard XDG/Windows paths
+    process.env.APPDATA ? { label: 'AppData/Claude', path: path.join(process.env.APPDATA, 'Claude') } : null
+].filter(Boolean);
+
+export async function getContext() {
+    // 1. Identify Existing vs Missing Paths
+    const choices = [];
+
+    for (const c of CANDIDATE_PATHS) {
+        const exists = await fs.pathExists(c.path);
+        const icon = exists ? '[X]' : '[ ]';
+        const desc = exists ? 'Found' : 'Not found (will create)';
+        
+        choices.push({
+            title: `${icon} ${c.label} (${c.path})`,
+            description: desc,
+            value: c.path,
+            selected: exists // Pre-select existing environments
+        });
+    }
+
+    // 2. Prompt user with Multiselect
+    const response = await prompts({
+        type: 'multiselect',
+        name: 'targets',
+        message: 'Select target environment(s):',
+        choices: choices,
+        hint: '- Space to select. Return to submit',
+        instructions: false
+    });
+
+    if (!response.targets || response.targets.length === 0) {
+        console.log(kleur.gray('No targets selected. Exiting.'));
+        process.exit(0);
+    }
+
+    // 3. Ensure directories exist for selected targets
+    for (const target of response.targets) {
+        await fs.ensureDir(target);
+    }
+
+    return {
+        targets: response.targets, // Array of path strings
+        syncMode: config.get('syncMode'),
+        config
+    };
+}
+
+export function resetContext() {
+    config.clear();
+    console.log(kleur.yellow('Configuration cleared.'));
+}

package/lib/diff.js

@@ -0,0 +1,142 @@
+import path from 'path';
+import fs from 'fs-extra';
+import crypto from 'crypto';
+
+/**
+ * Calculate MD5 hash of a file or directory
+ */
+async function getHash(targetPath) {
+    if (!fs.existsSync(targetPath)) return null;
+
+    const stats = await fs.stat(targetPath);
+
+    if (stats.isDirectory()) {
+        const children = await fs.readdir(targetPath);
+        const childHashes = await Promise.all(
+            children.sort().map(async child => {
+                const h = await getHash(path.join(targetPath, child));
+                return `${child}:${h}`;
+            })
+        );
+        return crypto.createHash('md5').update(childHashes.join('|')).digest('hex');
+    } else {
+        const content = await fs.readFile(targetPath);
+        return crypto.createHash('md5').update(content).digest('hex');
+    }
+}
+
+async function getNewestMtime(targetPath) {
+    const stats = await fs.stat(targetPath);
+    let maxTime = stats.mtimeMs;
+
+    if (stats.isDirectory()) {
+        const children = await fs.readdir(targetPath);
+        for (const child of children) {
+            const childPath = path.join(targetPath, child);
+            const childTime = await getNewestMtime(childPath);
+            if (childTime > maxTime) maxTime = childTime;
+        }
+    }
+    return maxTime;
+}
+
+export async function calculateDiff(repoRoot, systemRoot) {
+    const isClaude = systemRoot.includes('.claude') || systemRoot.includes('Claude');
+    const isQwen = systemRoot.includes('.qwen') || systemRoot.includes('Qwen');
+    const isGemini = systemRoot.includes('.gemini') || systemRoot.includes('Gemini');
+
+    const changeSet = {
+        skills: { missing: [], outdated: [], drifted: [], total: 0 },
+        hooks: { missing: [], outdated: [], drifted: [], total: 0 },
+        config: { missing: [], outdated: [], drifted: [], total: 0 },
+        commands: { missing: [], outdated: [], drifted: [], total: 0 },
+        'qwen-commands': { missing: [], outdated: [], drifted: [], total: 0 },
+        'antigravity-workflows': { missing: [], outdated: [], drifted: [], total: 0 }
+    };
+
+    // 1. Folders: Skills & Hooks & Commands (for different environments)
+    const folders = ['skills', 'hooks'];
+    if (isQwen) {
+        folders.push('qwen-commands');
+    } else if (isGemini) {
+        folders.push('commands', 'antigravity-workflows');
+    } else if (!isClaude) {
+        folders.push('commands');
+    }
+
+    for (const category of folders) {
+        let repoPath;
+        if (category === 'commands') {
+            // Commands are always in .gemini/commands in repo
+            repoPath = path.join(repoRoot, '.gemini', 'commands');
+        } else if (category === 'qwen-commands') {
+            // Qwen commands are in .qwen/commands in repo
+            repoPath = path.join(repoRoot, '.qwen', 'commands');
+        } else if (category === 'antigravity-workflows') {
+            // Antigravity workflows are in .gemini/antigravity/global_workflows in repo
+            repoPath = path.join(repoRoot, '.gemini', 'antigravity', 'global_workflows');
+        } else {
+            repoPath = path.join(repoRoot, category);
+        }
+        
+        let systemPath;
+        if (category === 'qwen-commands') {
+            systemPath = path.join(systemRoot, 'commands');
+        } else if (category === 'antigravity-workflows') {
+            systemPath = path.join(systemRoot, '.gemini', 'antigravity', 'global_workflows');
+        } else if (category === 'commands') {
+            systemPath = path.join(systemRoot, category);
+        } else {
+            systemPath = path.join(systemRoot, category);
+        }
+
+        if (!fs.existsSync(repoPath)) continue;
+
+        const items = await fs.readdir(repoPath);
+        changeSet[category].total = items.length;
+
+        for (const item of items) {
+            const itemRepoPath = path.join(repoPath, item);
+            const itemSystemPath = path.join(systemPath, item);
+
+            await compareItem(category, item, itemRepoPath, itemSystemPath, changeSet);
+        }
+    }
+
+    // 2. Config Files (Explicit Mapping)
+    const configMapping = {
+        'settings.json': { repo: 'config/settings.json', sys: 'settings.json' }
+    };
+
+    for (const [name, paths] of Object.entries(configMapping)) {
+        const itemRepoPath = path.join(repoRoot, paths.repo);
+        const itemSystemPath = path.join(systemRoot, paths.sys);
+        
+        if (fs.existsSync(itemRepoPath)) {
+            await compareItem('config', name, itemRepoPath, itemSystemPath, changeSet);
+        }
+    }
+
+    return changeSet;
+}
+
+async function compareItem(category, item, repoPath, systemPath, changeSet) {
+    if (!fs.existsSync(systemPath)) {
+        changeSet[category].missing.push(item);
+        return;
+    }
+
+    const repoHash = await getHash(repoPath);
+    const systemHash = await getHash(systemPath);
+
+    if (repoHash !== systemHash) {
+        const repoMtime = await getNewestMtime(repoPath);
+        const systemMtime = await getNewestMtime(systemPath);
+
+        if (systemMtime > repoMtime + 2000) {
+            changeSet[category].drifted.push(item);
+        } else {
+            changeSet[category].outdated.push(item);
+        }
+    }
+}

package/lib/env-manager.js

@@ -0,0 +1,160 @@
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
+import kleur from 'kleur';
+import dotenv from 'dotenv';
+
+/**
+ * Environment file location: ~/.config/jaggers-agent-tools/.env
+ */
+const CONFIG_DIR = path.join(os.homedir(), '.config', 'jaggers-agent-tools');
+const ENV_FILE = path.join(CONFIG_DIR, '.env');
+const ENV_EXAMPLE_FILE = path.join(CONFIG_DIR, '.env.example');
+
+/**
+ * Required environment variables for MCP servers
+ */
+const REQUIRED_ENV_VARS = {
+  'CONTEXT7_API_KEY': {
+    description: 'Context7 MCP server API key',
+    example: 'ctx7sk-your-api-key-here',
+    getUrl: () => 'https://context7.com/'
+  }
+};
+
+/**
+ * Ensure config directory and .env file exist
+ */
+export function ensureEnvFile() {
+  // Create config directory if missing
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.ensureDirSync(CONFIG_DIR);
+    console.log(kleur.gray(`  Created config directory: ${CONFIG_DIR}`));
+  }
+
+  // Create .env.example if missing
+  if (!fs.existsSync(ENV_EXAMPLE_FILE)) {
+    createEnvExample();
+  }
+
+  // Create .env if missing
+  if (!fs.existsSync(ENV_FILE)) {
+    createEnvFile();
+    return false; // File was created (user needs to fill it)
+  }
+
+  return true; // File already exists
+}
+
+/**
+ * Create .env.example file
+ */
+function createEnvExample() {
+  const content = [
+    '# Jaggers Agent Tools - Environment Variables',
+    '# Copy this file to .env and fill in your actual values',
+    '',
+    ...Object.entries(REQUIRED_ENV_VARS).map(([key, config]) => {
+      return [
+        `# ${config.description}`,
+        `# Get your key from: ${config.getUrl()}`,
+        `${key}=${config.example}`,
+        ''
+      ].join('\n');
+    }).join('\n'),
+    '# See config/.env.example in the repository for all available options',
+    ''
+  ];
+
+  fs.writeFileSync(ENV_EXAMPLE_FILE, content);
+  console.log(kleur.gray(`  Created example file: ${ENV_EXAMPLE_FILE}`));
+}
+
+/**
+ * Create empty .env file with header
+ */
+function createEnvFile() {
+  const content = [
+    '# Jaggers Agent Tools - Environment Variables',
+    '# Generated automatically by jaggers-agent-tools CLI',
+    '',
+    '# Copy values from .env.example and fill in your actual keys',
+    '',
+  ].join('\n');
+
+  fs.writeFileSync(ENV_FILE, content);
+  console.log(kleur.green(`  Created environment file: ${ENV_FILE}`));
+}
+
+/**
+ * Load environment variables from .env file
+ * Also loads from process.env (which takes precedence)
+ */
+export function loadEnvFile() {
+  if (fs.existsSync(ENV_FILE)) {
+    const envConfig = dotenv.parse(fs.readFileSync(ENV_FILE));
+    
+    // Merge with process.env (process.env takes precedence)
+    for (const [key, value] of Object.entries(envConfig)) {
+      if (!process.env[key]) {
+        process.env[key] = value;
+      }
+    }
+    
+    return envConfig;
+  }
+  
+  return {};
+}
+
+/**
+ * Check if required environment variables are set
+ * Returns array of missing variable names
+ */
+export function checkRequiredEnvVars() {
+  const missing = [];
+  
+  for (const [key, config] of Object.entries(REQUIRED_ENV_VARS)) {
+    if (!process.env[key]) {
+      missing.push(key);
+    }
+  }
+  
+  return missing;
+}
+
+/**
+ * Prompt user about missing environment variables
+ * Returns true if user wants to proceed anyway
+ */
+export function handleMissingEnvVars(missing) {
+  if (missing.length === 0) {
+    return true;
+  }
+
+  console.log(kleur.yellow('\n  ⚠️  Missing environment variables:'));
+  for (const key of missing) {
+    const config = REQUIRED_ENV_VARS[key];
+    console.log(kleur.yellow(`    - ${key}: ${config.description}`));
+    console.log(kleur.dim(`      Get your key from: ${config.getUrl()}`));
+  }
+
+  console.log(kleur.yellow(`\n  Please edit: ${ENV_FILE}`));
+  console.log(kleur.gray(`  Or copy from example: ${ENV_EXAMPLE_FILE}`));
+  
+  return false; // Don't proceed automatically
+}
+
+/**
+ * Get the path to the .env file
+ */
+export function getEnvFilePath() {
+  return ENV_FILE;
+}
+
+/**
+ * Get the path to the config directory
+ */
+export function getConfigDir() {
+  return CONFIG_DIR;
+}