xtrm-cli 2.1.4

package/lib/sync-mcp-cli.js

@@ -0,0 +1,345 @@
+import { execSync } from 'child_process';
+import fs from 'fs-extra';
+import path from 'path';
+import kleur from 'kleur';
+import { ensureEnvFile, loadEnvFile, checkRequiredEnvVars, handleMissingEnvVars, getEnvFilePath } from './env-manager.js';
+
+/**
+ * Agent-specific MCP CLI handlers
+ */
+const AGENT_CLI = {
+  claude: {
+    command: 'claude',
+    listArgs: ['mcp', 'list'], // list doesn't support -s flag
+    addStdio: (name, cmd, args, env) => {
+      // Use -s user for user-level config (~/.claude.json global)
+      const base = ['mcp', 'add', '-s', 'user', name, '--'];
+      if (env && Object.keys(env).length > 0) {
+        for (const [key, value] of Object.entries(env)) {
+          base.push('-e', `${key}=${resolveEnvVar(value)}`);
+        }
+      }
+      base.push(cmd, ...(args || []));
+      return base;
+    },
+    addHttp: (name, url, headers) => {
+      // Use -s user for user-level config
+      const base = ['mcp', 'add', '-s', 'user', '--transport', 'http', name, url];
+      if (headers) {
+        for (const [key, value] of Object.entries(headers)) {
+          base.push('--header', `${key}: ${resolveEnvVar(value)}`);
+        }
+      }
+      return base;
+    },
+    addSse: (name, url) => {
+      return ['mcp', 'add', '-s', 'user', '--transport', 'sse', name, url];
+    },
+    remove: (name) => ['mcp', 'remove', '-s', 'user', name],
+    parseList: (output) => parseMcpListOutput(output, /^([a-zA-Z0-9_-]+):/)
+  },
+  gemini: {
+    command: 'gemini',
+    listArgs: ['mcp', 'list'],
+    addStdio: (name, cmd, args, env) => {
+      const base = ['mcp', 'add', name, cmd];
+      if (args && args.length > 0) base.push(...args);
+      if (env && Object.keys(env).length > 0) {
+        for (const [key, value] of Object.entries(env)) {
+          base.push('-e', `${key}=${resolveEnvVar(value)}`);
+        }
+      }
+      return base;
+    },
+    addHttp: (name, url, headers) => {
+      const base = ['mcp', 'add', '-t', 'http', name, url];
+      if (headers) {
+        for (const [key, value] of Object.entries(headers)) {
+          base.push('-H', `${key}=${resolveEnvVar(value)}`);
+        }
+      }
+      return base;
+    },
+    addSse: (name, url) => {
+      return ['mcp', 'add', '-t', 'sse', name, url];
+    },
+    remove: (name) => ['mcp', 'remove', name],
+    parseList: (output) => parseMcpListOutput(output, /^✓ ([a-zA-Z0-9_-]+):/)
+  },
+  qwen: {
+    command: 'qwen',
+    listArgs: ['mcp', 'list'],
+    addStdio: (name, cmd, args, env) => {
+      const base = ['mcp', 'add', name, cmd];
+      if (args && args.length > 0) base.push(...args);
+      if (env && Object.keys(env).length > 0) {
+        for (const [key, value] of Object.entries(env)) {
+          base.push('-e', `${key}=${resolveEnvVar(value)}`);
+        }
+      }
+      return base;
+    },
+    addHttp: (name, url, headers) => {
+      const base = ['mcp', 'add', '-t', 'http', name, url];
+      if (headers) {
+        for (const [key, value] of Object.entries(headers)) {
+          base.push('-H', `${key}=${resolveEnvVar(value)}`);
+        }
+      }
+      return base;
+    },
+    addSse: (name, url) => {
+      return ['mcp', 'add', '-t', 'sse', name, url];
+    },
+    remove: (name) => ['mcp', 'remove', name],
+    parseList: (output) => parseMcpListOutput(output, /^✓ ([a-zA-Z0-9_-]+):/)
+  }
+};
+
+/**
+ * Parse MCP list output to extract server names
+ */
+function parseMcpListOutput(output, pattern) {
+  const servers = [];
+  for (const line of output.split('\n')) {
+    const match = line.match(pattern);
+    if (match) {
+      servers.push(match[1]);
+    }
+  }
+  return servers;
+}
+
+/**
+ * Resolve environment variable references like ${VAR}
+ */
+function resolveEnvVar(value) {
+  if (typeof value !== 'string') return value;
+  
+  const envMatch = value.match(/\$\{([A-Z0-9_]+)\}/i);
+  if (envMatch) {
+    const envName = envMatch[1];
+    const envValue = process.env[envName];
+    if (envValue) {
+      return envValue;
+    } else {
+      // Return empty string - server will be added but won't work until key is added
+      console.warn(kleur.yellow(`  ⚠️  Environment variable ${envName} is not set in ${getEnvFilePath()}`));
+      return '';
+    }
+  }
+  
+  return value;
+}
+
+/**
+ * Detect which agent CLI is available
+ */
+export function detectAgent(systemRoot) {
+  if (systemRoot.includes('.claude') || systemRoot.includes('Claude')) {
+    return 'claude';
+  } else if (systemRoot.includes('.gemini') || systemRoot.includes('Gemini')) {
+    return 'gemini';
+  } else if (systemRoot.includes('.qwen') || systemRoot.includes('Qwen')) {
+    return 'qwen';
+  }
+  return null;
+}
+
+/**
+ * Build MCP add commands for a server
+ */
+function buildAddCommand(agent, name, server) {
+  const cli = AGENT_CLI[agent];
+  if (!cli) return null;
+
+  // HTTP/SSE servers
+  if (server.url || server.serverUrl) {
+    const url = server.url || server.serverUrl;
+    const type = server.type || (url.includes('/sse') ? 'sse' : 'http');
+    
+    if (type === 'sse') {
+      return cli.addSse(name, url);
+    } else {
+      return cli.addHttp(name, url, server.headers);
+    }
+  }
+  
+  // Stdio servers
+  if (server.command) {
+    return cli.addStdio(name, server.command, server.args, server.env);
+  }
+  
+  console.warn(kleur.yellow(`  ⚠️  Skipping server "${name}": Unknown configuration`));
+  return null;
+}
+
+/**
+ * Execute an MCP command
+ */
+function executeCommand(agent, args, dryRun = false) {
+  const cli = AGENT_CLI[agent];
+  
+  // Build command string with proper quoting for arguments with spaces
+  const quotedArgs = args.map(arg => {
+    if (arg.includes(' ') && !arg.startsWith('"') && !arg.startsWith("'")) {
+      return `"${arg}"`;
+    }
+    return arg;
+  });
+  const command = `${cli.command} ${quotedArgs.join(' ')}`;
+  
+  if (dryRun) {
+    console.log(kleur.cyan(`  [DRY RUN] ${command}`));
+    return { success: true, dryRun: true };
+  }
+
+  try {
+    execSync(command, { stdio: 'pipe' });
+    console.log(kleur.green(`  ✓ ${args.slice(2).join(' ')}`));
+    return { success: true };
+  } catch (error) {
+    const stderr = error.stderr?.toString() || error.message;
+    
+    // Handle "already exists" case as success (idempotent)
+    if (stderr.includes('already exists') || stderr.includes('already configured')) {
+      // Extract server name based on agent
+      let serverName = 'unknown';
+      if (agent === 'claude') {
+        // Claude: claude mcp add [-s scope] [--transport type] <name> ...
+        // Find the server name: first non-flag arg after 'add' that's not scope or transport
+        const addIndex = args.indexOf('add');
+        for (let i = addIndex + 1; i < args.length; i++) {
+          const arg = args[i];
+          if (arg === '--') continue; // Skip separator
+          if (arg.startsWith('-')) continue; // Skip flags
+          if (['local', 'user', 'project', 'http', 'sse', 'stdio'].includes(arg)) continue; // Skip scope and transport
+          serverName = arg;
+          break;
+        }
+      } else if (agent === 'gemini' || agent === 'qwen') {
+        // Gemini/Qwen: <agent> mcp add [-t type] <name> <url>...
+        // Find first non-flag arg after 'add' that's not a transport type
+        const addIndex = args.indexOf('add');
+        for (let i = addIndex + 1; i < args.length; i++) {
+          const arg = args[i];
+          if (arg === '-t') { i++; continue; } // Skip transport flag and value
+          if (arg.startsWith('-')) continue; // Skip other flags
+          if (['http', 'sse', 'stdio'].includes(arg)) continue; // Skip transport types
+          serverName = arg;
+          break;
+        }
+      } else {
+        // Fallback: use third arg
+        serverName = args[2];
+      }
+      console.log(kleur.dim(`  ✓ ${serverName} (already configured)`));
+      return { success: true, skipped: true };
+    }
+    
+    console.log(kleur.red(`  ✗ Failed: ${stderr.trim()}`));
+    return { success: false, error: stderr };
+  }
+}
+
+/**
+ * Get current MCP servers for an agent
+ */
+function getCurrentServers(agent) {
+  const cli = AGENT_CLI[agent];
+  try {
+    const output = execSync(`${cli.command} ${cli.listArgs.join(' ')}`, { 
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'ignore']
+    });
+    return cli.parseList(output);
+  } catch (error) {
+    return [];
+  }
+}
+
+/**
+ * Sync MCP servers to an agent using official CLI
+ * 
+ * @param {string} agent - 'claude', 'gemini', or 'qwen'
+ * @param {Object} mcpConfig - Canonical MCP configuration
+ * @param {boolean} dryRun - Show commands without executing
+ * @param {boolean} prune - Remove servers not in canonical config
+ */
+export async function syncMcpServersWithCli(agent, mcpConfig, dryRun = false, prune = false) {
+  const cli = AGENT_CLI[agent];
+  if (!cli) {
+    console.log(kleur.yellow(`  ⚠️  Unsupported agent: ${agent}`));
+    return;
+  }
+
+  console.log(kleur.bold(`\nSyncing MCP servers to ${agent}...`));
+
+  // Step 0: Ensure .env file exists and load it
+  ensureEnvFile();
+  loadEnvFile();
+
+  // Step 1: Check for missing required env vars
+  const missingEnvVars = checkRequiredEnvVars();
+  if (missingEnvVars.length > 0) {
+    handleMissingEnvVars(missingEnvVars);
+    // Continue anyway - servers will be added but may not work until keys are added
+  }
+
+  // Step 2: Get current servers
+  const currentServers = getCurrentServers(agent);
+  const canonicalServers = new Set(Object.keys(mcpConfig.mcpServers || {}));
+
+  // Step 2: Remove servers not in canonical (if prune mode)
+  if (prune) {
+    console.log(kleur.red('\n  Prune mode: Removing servers not in canonical config...'));
+    for (const serverName of currentServers) {
+      if (!canonicalServers.has(serverName)) {
+        console.log(kleur.red(`  Removing: ${serverName}`));
+        executeCommand(agent, cli.remove(serverName), dryRun);
+      }
+    }
+  }
+
+  // Step 3: Add/update canonical servers
+  console.log(kleur.cyan('\n  Adding/Updating canonical servers...'));
+  let successCount = 0;
+  
+  for (const [name, server] of Object.entries(mcpConfig.mcpServers)) {
+    const cmd = buildAddCommand(agent, name, server);
+    if (cmd) {
+      const result = executeCommand(agent, cmd, dryRun);
+      if (result.success) {
+        successCount++;
+      }
+    }
+  }
+
+  // Summary
+  console.log(kleur.green(`\n  ✓ Synced ${successCount} MCP servers`));
+}
+
+/**
+ * Load canonical MCP config from repository
+ */
+export function loadCanonicalMcpConfig(repoRoot) {
+  const corePath = path.join(repoRoot, 'config', 'mcp_servers.json');
+  const optionalPath = path.join(repoRoot, 'config', 'mcp_servers_optional.json');
+  
+  const config = { mcpServers: {} };
+  
+  // Always load core servers
+  if (fs.existsSync(corePath)) {
+    const core = fs.readJsonSync(corePath);
+    config.mcpServers = { ...config.mcpServers, ...core.mcpServers };
+  }
+  
+  // Optionally load optional servers (user would have selected these)
+  // For now, we don't auto-load them
+  // if (fs.existsSync(optionalPath)) {
+  //   const optional = fs.readJsonSync(optionalPath);
+  //   config.mcpServers = { ...config.mcpServers, ...optional.mcpServers };
+  // }
+  
+  return config;
+}

package/lib/sync.js

@@ -0,0 +1,227 @@
+import path from 'path';
+import fs from 'fs-extra';
+import kleur from 'kleur';
+import { transformGeminiConfig, transformSkillToCommand } from './transform-gemini.js';
+import { safeMergeConfig } from './atomic-config.js';
+import { ConfigAdapter } from './config-adapter.js';
+import { syncMcpServersWithCli, loadCanonicalMcpConfig, detectAgent } from './sync-mcp-cli.js';
+
+/**
+ * Execute a sync plan based on changeset and mode
+ */
+export async function executeSync(repoRoot, systemRoot, changeSet, mode, actionType, isDryRun = false) {
+  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 categories = ['skills', 'hooks', 'config'];
+  
+  if (isQwen) {
+    categories.push('qwen-commands');
+  } else if (isGemini) {
+    categories.push('commands', 'antigravity-workflows');
+  } else if (!isClaude) {
+    categories.push('commands');
+  }
+
+  let count = 0;
+  const adapter = new ConfigAdapter(systemRoot);
+
+  // Special handling for agents with official MCP CLI: Always sync MCP servers
+  // Supported: claude, gemini, qwen
+  const agent = detectAgent(systemRoot);
+  if (agent && actionType === 'sync') {
+    console.log(kleur.gray(`  --> ${agent} MCP servers (via ${agent} mcp CLI)`));
+    
+    // Load canonical MCP config
+    const canonicalConfig = loadCanonicalMcpConfig(repoRoot);
+    
+    // Sync using official CLI
+    await syncMcpServersWithCli(agent, canonicalConfig, isDryRun, mode === 'prune');
+    
+    count++;
+  }
+
+  for (const category of categories) {
+    const itemsToProcess = [];
+
+    if (actionType === 'sync') {
+      itemsToProcess.push(...changeSet[category].missing);
+      itemsToProcess.push(...changeSet[category].outdated);
+
+      // PRUNE: Handle removals from system if no longer in repo
+      if (mode === 'prune') {
+        for (const itemToDelete of changeSet[category].drifted || []) {
+           const dest = path.join(systemRoot, category, itemToDelete);
+           console.log(kleur.red(`  [x] PRUNING ${category}/${itemToDelete}`));
+           if (!isDryRun) await fs.remove(dest);
+           count++;
+        }
+      }
+    } else if (actionType === 'backport') {
+      itemsToProcess.push(...changeSet[category].drifted);
+    }
+
+    for (const item of itemsToProcess) {
+      let src, dest;
+
+      if (category === 'config' && item === 'settings.json' && actionType === 'sync') {
+        src = path.join(repoRoot, 'config', 'settings.json');
+        dest = path.join(systemRoot, 'settings.json');
+
+        console.log(kleur.gray(`  --> config/settings.json`));
+
+        // Skip settings.json sync for agents with official MCP CLI
+        // MCP servers are managed via CLI, hooks are not supported
+        if (agent) {
+          console.log(kleur.gray(`  (Skipped: ${agent} uses ${agent} mcp CLI for MCP servers)`));
+          count++;
+          continue;
+        }
+
+        const repoConfig = await fs.readJson(src);
+        let finalRepoConfig = resolveConfigPaths(repoConfig, systemRoot);
+
+        // Inject Hooks
+        const hooksSrc = path.join(repoRoot, 'config', 'hooks.json');
+        if (await fs.pathExists(hooksSrc)) {
+          const hooksRaw = await fs.readJson(hooksSrc);
+          const hooksAdapted = adapter.adaptHooksConfig(hooksRaw);
+          if (hooksAdapted.hooks) {
+            finalRepoConfig.hooks = { ...(finalRepoConfig.hooks || {}), ...hooksAdapted.hooks };
+            if (!isDryRun) console.log(kleur.dim(`      (Injected hooks)`));
+          }
+        }
+
+        if (fs.existsSync(dest)) {
+          const localConfig = await fs.readJson(dest);
+          const resolvedLocalConfig = resolveConfigPaths(localConfig, systemRoot);
+
+          // Handle PRUNE mode for mcpServers and hooks
+          if (mode === 'prune') {
+            // Remove local MCP servers NOT in our canonical source
+            if (localConfig.mcpServers && finalRepoConfig.mcpServers) {
+                const canonicalServers = new Set(Object.keys(finalRepoConfig.mcpServers));
+                for (const serverName of Object.keys(localConfig.mcpServers)) {
+                    if (!canonicalServers.has(serverName)) {
+                        delete localConfig.mcpServers[serverName];
+                        if (!isDryRun) console.log(kleur.red(`      (Pruned local MCP server: ${serverName})`));
+                    }
+                }
+            }
+          }
+
+          const mergeResult = await safeMergeConfig(dest, finalRepoConfig, {
+            backupOnSuccess: true,
+            preserveComments: true,
+            dryRun: isDryRun,
+            resolvedLocalConfig: resolvedLocalConfig
+          });
+
+          if (mergeResult.updated) {
+            console.log(kleur.blue(`      (Configuration safely merged)`));
+          }
+        } else {
+          if (!isDryRun) {
+            await fs.ensureDir(path.dirname(dest));
+            await fs.writeJson(dest, finalRepoConfig, { spaces: 2 });
+          }
+          console.log(kleur.green(`      (Created new configuration)`));
+        }
+        count++;
+        continue;
+      }
+
+      // Standard file sync for other items
+      const repoPath = category === 'commands' ? path.join(repoRoot, '.gemini', 'commands') :
+                       category === 'qwen-commands' ? path.join(repoRoot, '.qwen', 'commands') :
+                       category === 'antigravity-workflows' ? path.join(repoRoot, '.gemini', 'antigravity', 'global_workflows') :
+                       path.join(repoRoot, category);
+
+      const systemPath = category === 'qwen-commands' ? path.join(systemRoot, 'commands') :
+                         category === 'antigravity-workflows' ? path.join(systemRoot, '.gemini', 'antigravity', 'global_workflows') :
+                         path.join(systemRoot, category);
+
+      if (actionType === 'backport') {
+        src = path.join(systemPath, item);
+        dest = path.join(repoPath, item);
+      } else {
+        src = path.join(repoPath, item);
+        dest = path.join(systemPath, item);
+      }
+
+      console.log(kleur.gray(`  ${actionType === 'backport' ? '<--' : '-->'} ${category}/${item}`));
+
+      if (mode === 'symlink' && actionType === 'sync' && category !== 'config') {
+        if (!isDryRun) {
+          await fs.remove(dest);
+          await fs.ensureSymlink(src, dest);
+        }
+      } else {
+        if (!isDryRun) {
+          await fs.remove(dest);
+          await fs.copy(src, dest);
+        }
+      }
+
+      // Gemini Skill -> Command transformation
+      if (category === 'skills' && !isClaude && actionType === 'sync') {
+        const skillMdPath = path.join(src, 'SKILL.md');
+        if (fs.existsSync(skillMdPath)) {
+          const result = await transformSkillToCommand(skillMdPath);
+          if (result && !isDryRun) {
+            const commandDest = path.join(systemRoot, 'commands', `${result.commandName}.toml`);
+            await fs.ensureDir(path.dirname(commandDest));
+            await fs.writeFile(commandDest, result.toml);
+            console.log(kleur.cyan(`      (Auto-generated slash command: /${result.commandName})`));
+          }
+        }
+      }
+
+      count++;
+    }
+  }
+
+  // Final Step: Write Sync Manifest
+  if (!isDryRun && actionType === 'sync') {
+    const manifestPath = path.join(systemRoot, '.jaggers-sync-manifest.json');
+    const manifest = {
+        lastSync: new Date().toISOString(),
+        repoRoot,
+        items: count
+    };
+    await fs.writeJson(manifestPath, manifest, { spaces: 2 });
+  }
+
+  return count;
+}
+
+/**
+ * Recursively resolves paths in the config to match the target directory
+ *
+ * This function corrects hardcoded paths (e.g. /home/dawid/...) to match the current user's home directory.
+ * It's applied to both repository config AND local config to ensure existing installations get updated.
+ *
+ * @param {Object} config - The configuration object to process
+ * @param {string} targetDir - The target directory (e.g. /home/jagger/.claude)
+ * @returns {Object} - New config object with resolved paths
+ */
+function resolveConfigPaths(config, targetDir) {
+  const newConfig = JSON.parse(JSON.stringify(config));
+
+  function recursiveReplace(obj) {
+    for (const key in obj) {
+      if (typeof obj[key] === 'string') {
+        // Match absolute paths containing /hooks/ and replace the prefix with targetDir/hooks
+        if (obj[key].match(/\/[^\s"']+\/hooks\//)) {
+           const hooksDir = path.join(targetDir, 'hooks');
+           obj[key] = obj[key].replace(/(\/[^\s"']+\/hooks\/)/g, `${hooksDir}/`);
+        }
+      } else if (typeof obj[key] === 'object' && obj[key] !== null) {
+        recursiveReplace(obj[key]);
+      }
+    }
+  }
+
+  recursiveReplace(newConfig);
+  return newConfig;
+}

package/lib/transform-gemini.js

@@ -0,0 +1,119 @@
+import fs from 'fs-extra';
+
+/**
+ * Transform Claude settings.json to Gemini-compatible format
+ */
+export function transformGeminiConfig(claudeConfig, targetDir) {
+    const geminiConfig = {
+        hooks: {}
+    };
+
+    if (claudeConfig.hooks) {
+        for (const [event, hooks] of Object.entries(claudeConfig.hooks)) {
+            const geminiEvent = mapEventName(event);
+            if (!geminiEvent) continue;
+            geminiConfig.hooks[geminiEvent] = hooks.map(def => transformHookDefinition(def, targetDir));
+        }
+    }
+
+    return geminiConfig;
+}
+
+function mapEventName(claudeEvent) {
+    const map = {
+        'UserPromptSubmit': 'BeforeAgent',
+        'PreToolUse': 'BeforeTool',
+        'SessionStart': 'SessionStart',
+    };
+    return map[claudeEvent] || null;
+}
+
+function transformHookDefinition(claudeDef, targetDir) {
+    const geminiDef = {
+        hooks: []
+    };
+
+    if (claudeDef.matcher) {
+        let matcher = claudeDef.matcher;
+        const toolMap = {
+            'Read': 'read_file',
+            'Write': 'write_file',
+            'Edit': 'replace',
+            'Bash': 'run_shell_command'
+        };
+
+        for (const [claudeTool, geminiTool] of Object.entries(toolMap)) {
+            const regex = new RegExp(`\\b${claudeTool}\\b`, 'g');
+            matcher = matcher.replace(regex, geminiTool);
+        }
+        
+        geminiDef.matcher = matcher;
+    }
+
+    geminiDef.hooks = claudeDef.hooks.map((h, index) => {
+        const cmd = h.command;
+        let newCommand = cmd;
+        if (targetDir) {
+             const claudePathRegex = /(\/[^\s"']+\.claude)/g;
+             newCommand = newCommand.replace(claudePathRegex, (match) => {
+                 return targetDir;
+             });
+        }
+
+        return {
+            name: h.name || `generated-hook-${index}`,
+            type: "command",
+            command: newCommand,
+            timeout: h.timeout || 60000
+        };
+    });
+
+    return geminiDef;
+}
+
+/**
+ * Transform a SKILL.md file into a Gemini command .toml content
+ */
+export async function transformSkillToCommand(skillMdPath) {
+    try {
+        const content = await fs.readFile(skillMdPath, 'utf8');
+        
+        // Extract frontmatter
+        const frontmatterMatch = content.match(/^---([\s\S]+?)---/);
+        if (!frontmatterMatch) return null;
+        
+        const frontmatter = frontmatterMatch[1];
+        
+        // Extract required and optional fields
+        const nameMatch = frontmatter.match(/name:\s*(.+)/);
+        const descMatch = frontmatter.match(/description:\s*(.+)/);
+        const geminiCmdMatch = frontmatter.match(/gemini-command:\s*(.+)/);
+        const geminiPromptMatch = frontmatter.match(/gemini-prompt:\s*\|?\s*\n?([\s\S]+?)(?=\n[a-z- ]+:|$)/);
+        
+        if (!nameMatch || !descMatch) return null;
+        
+        const name = nameMatch[1].trim();
+        const description = descMatch[1].trim();
+        const commandName = geminiCmdMatch ? geminiCmdMatch[1].trim() : name;
+        
+        let promptBody = `Use the ${name} skill to handle this: {{args}}`;
+        if (geminiPromptMatch) {
+            // Indent the extra prompt lines properly if they aren't already
+            const extraLines = geminiPromptMatch[1].trim();
+            promptBody = `Use the ${name} skill to handle this request: {{args}}\n\n${extraLines}`;
+        }
+        
+        const toml = `description = """${description}"""
+prompt = """
+${promptBody}
+"""
+`;
+        return {
+            toml,
+            commandName
+        };
+    } catch (error) {
+        console.error(`Error transforming skill to command: ${error.message}`);
+        return null;
+    }
+}