llm-tuner 0.3.0 → 0.4.0

package/src/cli/router.js

@@ -0,0 +1,243 @@
+import { select } from '@inquirer/prompts';
+import { readSettings, writeSettings, THEMES, PROFILES, CURRENT_VERSION } from '../core/index.js';
+import { t as translate, LOCALES, errorText } from '../i18n/index.js';
+import { loadCommand } from './commands/load.js';
+import { mcpCommand } from './commands/mcp.js';
+import { presetsCommand } from './commands/presets.js';
+import { settingsCommand } from './commands/settings.js';
+import { helpCommand } from './commands/help.js';
+import { withNav } from './nav.js';
+
+export function parseCliArgs(argv) {
+  const flags = new Set(['help', 'version', 'yes', 'dry-run', 'json', 'force', 'presets', 'settings']);
+  const tuningKeys = new Set(['engine', 'model', 'ctx', 'profile', 'candidates', 'force', 'dry-run', 'yes', 'json']);
+  const args = {};
+  let command = null;
+
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+
+    // Slash commands or positional aliases
+    if (a === '/load' || a === 'load') {
+      command = 'load';
+      continue;
+    }
+    if (a === '/mcp' || a === 'mcp') {
+      command = 'mcp';
+      continue;
+    }
+    if (a === '/presets' || a === 'presets') {
+      command = 'presets';
+      continue;
+    }
+    if (a === '/settings' || a === 'settings' || a === '/setting' || a === 'setting') {
+      command = 'settings';
+      args.settings = true;
+      continue;
+    }
+    if (a === '/help' || a === 'help') {
+      command = 'help';
+      args.help = true;
+      continue;
+    }
+    if (a === '/exit' || a === 'exit') {
+      command = 'exit';
+      continue;
+    }
+
+    // Short flags
+    if (a === '-h') { args.help = true; command = 'help'; continue; }
+    if (a === '-v') { args.version = true; command = 'version'; continue; }
+
+    // Double-dash flags & options
+    if (a.startsWith('--')) {
+      const k = a.slice(2);
+      if (k === 'setting' || k === 'settings') {
+        args.settings = true;
+        command = 'settings';
+        continue;
+      }
+      if (k === 'presets') {
+        args.presets = true;
+        command = 'presets';
+        continue;
+      }
+      if (k === 'help') {
+        args.help = true;
+        command = 'help';
+        continue;
+      }
+      if (k === 'version') {
+        args.version = true;
+        command = 'version';
+        continue;
+      }
+
+      if (flags.has(k)) {
+        args[k] = true;
+      } else {
+        args[k] = argv[++i];
+      }
+      continue;
+    }
+  }
+
+  // Normalize dry-run / dryRun
+  if (args['dry-run']) args.dryRun = true;
+  else if (args.dryRun) args['dry-run'] = true;
+
+  // Route fallback: if command not explicitly set
+  if (!command) {
+    const hasTuning = Object.keys(args).some((k) => tuningKeys.has(k));
+    if (hasTuning) {
+      command = 'load';
+    } else {
+      command = 'menu';
+    }
+  }
+
+  return { command, ...args };
+}
+
+export async function routeCli(argv, env = {}) {
+  const parsed = parseCliArgs(argv);
+  let { command, ...args } = parsed;
+
+  let { lang, theme } = await readSettings();
+  const t = (key, params) => translate(lang, key, params);
+
+  if ('lang' in args) {
+    if (!LOCALES.includes(args.lang)) {
+      console.error(translate('en', 'errors.unknownLocale', { lang: args.lang ?? '', list: LOCALES.join(', ') }));
+      return 1;
+    }
+    lang = args.lang;
+    try { await writeSettings({ lang }); } catch (e) { console.error(`Warning: ${e.message}`); }
+  }
+
+  if ('theme' in args) {
+    if (!THEMES.includes(args.theme)) {
+      console.error(translate(lang, 'errors.unknownTheme', { theme: args.theme ?? '', list: THEMES.join(', ') }));
+      return 1;
+    }
+    theme = args.theme;
+    try { await writeSettings({ theme }); } catch (e) { console.error(`Warning: ${e.message}`); }
+  }
+
+  if ('profile' in args) {
+    if (!PROFILES.includes(args.profile)) {
+      console.error(translate(lang, 'errors.unknownProfile', { profile: args.profile ?? '', list: PROFILES.join(', ') }));
+      return 1;
+    }
+  }
+
+  if (command === 'version' || args.version) {
+    console.log(CURRENT_VERSION);
+    return 0;
+  }
+
+  if (command === 'help' || args.help) {
+    await helpCommand(args, { lang, theme });
+    return 0;
+  }
+
+  // Interactive menu mode when run bare (persistent loop until /exit)
+  if (command === 'menu') {
+    const isInteractive = process.stdin.isTTY || env.forceInteractive;
+    if (!isInteractive) {
+      await loadCommand(args, { lang, theme });
+      return 0;
+    }
+
+    let currentLang = lang;
+    let currentTheme = theme;
+
+    while (true) {
+      const activeT = (k, p) => translate(currentLang, k, p);
+      let selectedCommand;
+
+      try {
+        selectedCommand = await withNav(() => select({
+          message: activeT('cli.menuTitle'),
+          choices: [
+            { name: `/load     ${activeT('cli.cmdLoadDesc')}`, value: 'load' },
+            { name: `/mcp      ${activeT('cli.cmdMcpDesc')}`, value: 'mcp' },
+            { name: `/presets  ${activeT('cli.cmdPresetsDesc')}`, value: 'presets' },
+            { name: `/settings ${activeT('cli.cmdSettingsDesc')}`, value: 'settings' },
+            { name: `/help     ${activeT('cli.cmdHelpDesc')}`, value: 'help' },
+            { name: `/exit     ${activeT('cli.cmdExitDesc')}`, value: 'exit' },
+          ],
+        }), { allowBack: false });
+      } catch (e) {
+        if (e?.name === 'ExitPromptError') {
+          return 0;
+        }
+        throw e;
+      }
+
+      if (selectedCommand === 'exit') {
+        return 0;
+      }
+
+      try {
+        switch (selectedCommand) {
+          case 'load':
+            await loadCommand(args, { lang: currentLang, theme: currentTheme });
+            break;
+          case 'mcp':
+            await mcpCommand(args, { lang: currentLang, theme: currentTheme });
+            break;
+          case 'presets':
+            await presetsCommand(args, { lang: currentLang, theme: currentTheme });
+            break;
+          case 'settings':
+            await settingsCommand(args, { lang: currentLang, theme: currentTheme });
+            {
+              const s = await readSettings();
+              currentLang = s.lang;
+              currentTheme = s.theme;
+            }
+            break;
+          case 'help':
+            await helpCommand(args, { lang: currentLang, theme: currentTheme });
+            break;
+        }
+      } catch (e) {
+        if (e?.name === 'ExitPromptError') {
+          // Sub-command was cancelled, return to main menu
+        } else {
+          console.error(`\n${activeT('common.error', { message: errorText(currentLang, e) })}`);
+        }
+      }
+
+      console.log('');
+    }
+  }
+
+  try {
+    switch (command) {
+      case 'load':
+        await loadCommand(args, { lang, theme });
+        return 0;
+      case 'mcp':
+        await mcpCommand(args, { lang, theme });
+        return 0;
+      case 'presets':
+        await presetsCommand(args, { lang, theme });
+        return 0;
+      case 'settings':
+        await settingsCommand(args, { lang, theme });
+        return 0;
+      case 'help':
+        await helpCommand(args, { lang, theme });
+        return 0;
+      default:
+        console.error(`Unknown command: ${command}`);
+        return 1;
+    }
+  } catch (e) {
+    if (e?.name === 'ExitPromptError') return 130;
+    console.error(`\n${t('common.error', { message: errorText(lang, e) })}`);
+    return 1;
+  }
+}

package/src/core/index.js

@@ -10,3 +10,4 @@ export { readSettings, writeSettings, settingsPath, THEMES, DEFAULT_THEME, norma
 export { TunerError, benchError } from './errors.js';
 export { sampleRam, sampleGpus, startTelemetrySampler } from './telemetry.js';
 export { checkUpdate, isNewerVersion, CURRENT_VERSION } from './updater.js';
+export { detectAgents, installMcpServer, SUPPORTED_AGENTS } from './mcp/index.js';

package/src/core/mcp/adapters/json-adapter.js

@@ -0,0 +1,37 @@
+import { readJson, writeJsonWithBackup } from '../../util.js';
+
+export async function readJsonMcpServers(filePath, rootKey) {
+  const data = (await readJson(filePath, {})) || {};
+  return Object.keys(data[rootKey] || {});
+}
+
+export async function upsertJsonMcpServer(
+  filePath,
+  rootKey,
+  serverName,
+  serverConfig,
+  { isOpenCode = false } = {}
+) {
+  const data = (await readJson(filePath, {})) || {};
+
+  if (!data[rootKey] || typeof data[rootKey] !== 'object') {
+    data[rootKey] = {};
+  }
+
+  if (isOpenCode) {
+    data[rootKey][serverName] = {
+      type: 'local',
+      command: [serverConfig.command, ...(serverConfig.args || [])],
+      environment: serverConfig.env || {}
+    };
+  } else {
+    data[rootKey][serverName] = {
+      command: serverConfig.command,
+      args: serverConfig.args || [],
+      ...(serverConfig.env ? { env: serverConfig.env } : {})
+    };
+  }
+
+  const backup = await writeJsonWithBackup(filePath, data, { indent: 2 });
+  return { backup };
+}

package/src/core/mcp/adapters/toml-adapter.js

@@ -0,0 +1,82 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { exists, timestamp } from '../../util.js';
+
+export async function readTomlMcpServers(filePath) {
+  if (!(await exists(filePath))) return [];
+
+  const content = await fs.readFile(filePath, 'utf8');
+  const lines = content.split(/\r?\n/);
+  const serverNames = new Set();
+
+  for (const raw of lines) {
+    const line = raw.trim();
+    const match = line.match(/^\[mcp_servers\.([A-Za-z0-9_-]+)\]\s*$/);
+    if (match) {
+      serverNames.add(match[1]);
+    }
+  }
+
+  return [...serverNames];
+}
+
+export async function upsertTomlMcpServer(filePath, serverName, serverConfig) {
+  let content = '';
+  let backup = null;
+
+  if (await exists(filePath)) {
+    const backupPath = `${filePath}.bak-llm-tuner-${timestamp()}`;
+    await fs.copyFile(filePath, backupPath);
+    backup = backupPath;
+    content = await fs.readFile(filePath, 'utf8');
+  } else {
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    content = '';
+  }
+
+  const lines = content.split(/\r?\n/);
+  const newLines = [];
+  let skipping = false;
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+
+    if (trimmed.startsWith('[')) {
+      if (
+        trimmed === `[mcp_servers.${serverName}]` ||
+        trimmed.startsWith(`[mcp_servers.${serverName}.`)
+      ) {
+        skipping = true;
+        continue;
+      }
+      skipping = false;
+    }
+
+    if (!skipping) {
+      newLines.push(line);
+    }
+  }
+
+  let baseContent = newLines.join('\n').trim();
+  if (baseContent.length > 0) {
+    baseContent += '\n\n';
+  }
+
+  let tomlBlock = `[mcp_servers.${serverName}]\n`;
+  tomlBlock += `command = ${JSON.stringify(serverConfig.command)}\n`;
+  tomlBlock += `args = ${JSON.stringify(serverConfig.args || [])}\n`;
+
+  if (serverConfig.env && typeof serverConfig.env === 'object' && Object.keys(serverConfig.env).length > 0) {
+    tomlBlock += `\n[mcp_servers.${serverName}.env]\n`;
+    for (const [key, value] of Object.entries(serverConfig.env)) {
+      tomlBlock += `${key} = ${JSON.stringify(String(value))}\n`;
+    }
+  }
+
+  const finalContent = baseContent + tomlBlock;
+  const tempPath = path.join(path.dirname(filePath), `.${path.basename(filePath)}.tmp-${process.pid}`);
+  await fs.writeFile(tempPath, finalContent, 'utf8');
+  await fs.rename(tempPath, filePath);
+
+  return { backup };
+}

package/src/core/mcp/index.js

@@ -0,0 +1,82 @@
+import { exists } from '../util.js';
+import { SUPPORTED_AGENTS, resolveConfigPath, buildMcpPayload } from './registry.js';
+import { readJsonMcpServers, upsertJsonMcpServer } from './adapters/json-adapter.js';
+import { readTomlMcpServers, upsertTomlMcpServer } from './adapters/toml-adapter.js';
+
+export { SUPPORTED_AGENTS, resolveConfigPath, buildMcpPayload };
+
+export async function detectAgents({ platform, env, homedir } = {}) {
+  const results = [];
+
+  for (const agent of SUPPORTED_AGENTS) {
+    const configPath = resolveConfigPath(agent.id, { platform, env, homedir });
+    const fileExists = await exists(configPath);
+
+    let configuredServers = [];
+    if (fileExists) {
+      try {
+        if (agent.format === 'toml') {
+          configuredServers = await readTomlMcpServers(configPath);
+        } else {
+          configuredServers = await readJsonMcpServers(configPath, agent.rootKey);
+        }
+      } catch {
+        configuredServers = [];
+      }
+    }
+
+    results.push({
+      id: agent.id,
+      name: agent.name,
+      format: agent.format,
+      configPath,
+      detected: fileExists,
+      configuredServers
+    });
+  }
+
+  return results;
+}
+
+export async function installMcpServer(
+  { engineId, customName, agentIds = [], host, apiKey },
+  { platform, env, homedir } = {}
+) {
+  if (!engineId || !customName) {
+    throw new Error('engineId and customName are required');
+  }
+
+  const payload = buildMcpPayload(engineId, { customName, host, apiKey });
+  const updated = [];
+  const errors = [];
+
+  for (const agentId of agentIds) {
+    const agent = SUPPORTED_AGENTS.find((a) => a.id === agentId);
+    if (!agent) {
+      errors.push({ agentId, error: `Unsupported agent ID: ${agentId}` });
+      continue;
+    }
+
+    try {
+      const configPath = resolveConfigPath(agentId, { platform, env, homedir });
+
+      if (agent.format === 'toml') {
+        await upsertTomlMcpServer(configPath, customName, payload);
+      } else {
+        await upsertJsonMcpServer(
+          configPath,
+          agent.rootKey,
+          customName,
+          payload,
+          { isOpenCode: agent.isOpenCode }
+        );
+      }
+
+      updated.push(agentId);
+    } catch (err) {
+      errors.push({ agentId, error: err.message });
+    }
+  }
+
+  return { success: errors.length === 0, updated, errors };
+}

package/src/core/mcp/registry.js

@@ -0,0 +1,121 @@
+import os from 'node:os';
+import path from 'node:path';
+
+export const SUPPORTED_AGENTS = [
+  {
+    id: 'claude-desktop',
+    name: 'Claude Desktop',
+    format: 'json',
+    rootKey: 'mcpServers'
+  },
+  {
+    id: 'claude-code',
+    name: 'Claude Code',
+    format: 'json',
+    rootKey: 'mcpServers'
+  },
+  {
+    id: 'opencode',
+    name: 'OpenCode',
+    format: 'json',
+    rootKey: 'mcp',
+    isOpenCode: true
+  },
+  {
+    id: 'antigravity',
+    name: 'Antigravity',
+    format: 'json',
+    rootKey: 'mcpServers'
+  },
+  {
+    id: 'vscode',
+    name: 'VS Code',
+    format: 'json',
+    rootKey: 'servers'
+  },
+  {
+    id: 'chatgpt',
+    name: 'ChatGPT / Codex',
+    format: 'toml'
+  }
+];
+
+export function resolveConfigPath(agentId, { platform = process.platform, env = process.env, homedir = os.homedir() } = {}) {
+  const p = platform === 'win32' ? path.win32 : path.posix;
+
+  switch (agentId) {
+    case 'claude-desktop': {
+      if (platform === 'darwin') {
+        return p.join(homedir, 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
+      }
+      if (platform === 'win32') {
+        const appData = env.APPDATA || p.join(homedir, 'AppData', 'Roaming');
+        return p.join(appData, 'Claude', 'claude_desktop_config.json');
+      }
+      const configDir = env.XDG_CONFIG_HOME || p.join(homedir, '.config');
+      return p.join(configDir, 'Claude', 'claude_desktop_config.json');
+    }
+    case 'claude-code': {
+      const userProfile = (platform === 'win32' && env.USERPROFILE) ? env.USERPROFILE : homedir;
+      return p.join(userProfile, '.claude.json');
+    }
+    case 'opencode': {
+      if (platform === 'darwin') {
+        return p.join(homedir, 'Library', 'Application Support', 'opencode', 'opencode.json');
+      }
+      if (platform === 'win32') {
+        const appData = env.APPDATA || p.join(homedir, 'AppData', 'Roaming');
+        return p.join(appData, 'opencode', 'opencode.json');
+      }
+      const configDir = env.XDG_CONFIG_HOME || p.join(homedir, '.config');
+      return p.join(configDir, 'opencode', 'opencode.json');
+    }
+    case 'antigravity': {
+      const userProfile = (platform === 'win32' && env.USERPROFILE) ? env.USERPROFILE : homedir;
+      return p.join(userProfile, '.gemini', 'config', 'mcp_config.json');
+    }
+    case 'vscode': {
+      if (platform === 'darwin') {
+        return p.join(homedir, 'Library', 'Application Support', 'Code', 'User', 'mcp.json');
+      }
+      if (platform === 'win32') {
+        const appData = env.APPDATA || p.join(homedir, 'AppData', 'Roaming');
+        return p.join(appData, 'Code', 'User', 'mcp.json');
+      }
+      const configDir = env.XDG_CONFIG_HOME || p.join(homedir, '.config');
+      return p.join(configDir, 'Code', 'User', 'mcp.json');
+    }
+    case 'chatgpt': {
+      const userProfile = (platform === 'win32' && env.USERPROFILE) ? env.USERPROFILE : homedir;
+      return p.join(userProfile, '.codex', 'config.toml');
+    }
+    default:
+      throw new Error(`Unsupported agent ID: ${agentId}`);
+  }
+}
+
+export function buildMcpPayload(engineId, { customName, host, apiKey } = {}) {
+  switch (engineId) {
+    case 'lmstudio': {
+      return {
+        command: 'npx',
+        args: ['-y', '@mzxrai/mcp-openai@latest'],
+        env: {
+          OPENAI_BASE_URL: host || 'http://127.0.0.1:1234/v1',
+          OPENAI_API_KEY: apiKey || 'sk-lm-local'
+        }
+      };
+    }
+    case 'ollama': {
+      return {
+        command: 'npx',
+        args: ['-y', 'ollama-mcp-server@latest'],
+        env: {
+          OLLAMA_HOST: host || 'http://127.0.0.1:11434'
+        }
+      };
+    }
+    default:
+      throw new Error(`Unsupported engine ID: ${engineId}`);
+  }
+}

package/src/i18n/en.js

@@ -95,24 +95,34 @@ export default {
   'common.longPrompt': 'long prompt (~{tokens} tokens, 50% context)…',
   'common.presetSaved': 'Preset saved: {file}',
   'common.backups': 'Backups: {list}',
+  'common.back': 'Back',
 
   // CLI
   'cli.help': `llm-tuner — load your local LLM with the fastest configuration for the context you need
 
-Usage: llm-tuner [options]
+Usage: llm-tuner [command] [options]
+
+Commands:
+  /load                        Tune and load a model with optimal hardware settings
+  /mcp                         Connect local engine to AI coding agents as MCP server
+  /presets                     List saved presets
+  /settings                    Interactive settings menu (language and theme)
+  /help                        Show this help message
+  /exit                        Exit the interactive menu
+
+Options:
   --engine <lmstudio|ollama>   Engine
   --model <key>                Model (LM Studio key or Ollama name)
   --ctx <tokens>               Context (e.g. 16384)
-  --profile <speed|balanced|quality>  What to optimize for (asked in the wizard; balanced with --yes, --json, or when engine, model and context are all given)
+  --profile <speed|balanced|quality>  What to optimize for (speed, balanced, quality)
   --force                      Measure again even if a preset exists
   --candidates <n>             Configurations to test when measuring (3)
   --yes                        Do not ask for confirmation
   --dry-run                    Measure and show the changes without applying anything or saving a preset
-  --presets                    List saved presets
+  --presets                    List saved presets (same as /presets)
   --json                       Final output as JSON
   --lang <en|es>               Interface language (saved for next time)
   --theme <system|light|dark>  Interface theme (saved for next time)
-  /settings                    Interactive settings menu
 
 Presets are saved in {presetsDir}`,
   'cli.desktopStartFailed': 'Could not start the desktop app: {error}\nThe desktop runtime (Electron) is downloaded the first time you run llm-tuner-desktop, so that first run needs a network connection.\nThe terminal interface works without it: run llm-tuner.',
@@ -249,5 +259,37 @@ Presets are saved in {presetsDir}`,
   'web.updateAvailable': 'Update available: v{latest}',
   'web.updateLink': 'View release notes on GitHub',
   'web.version': 'Version {version}',
+  'errors.missingParameter': 'Missing required parameter: {param}',
+  'web.addAsMcp': 'Add as MCP',
+  'web.addAsMcpTooltip': 'Configure this engine as an MCP server for your AI agents (Claude, OpenCode, VS Code, ChatGPT)',
+  'web.mcpModalTitle': 'Add {engine} as MCP Server',
+  'web.mcpServerName': 'MCP Server Name',
+  'web.mcpAdvancedOptions': 'Advanced connection options',
+  'web.mcpBaseUrl': 'Base URL / Host',
+  'web.mcpApiKey': 'API Key',
+  'web.mcpSelectAgents': 'Select AI agents to configure:',
+  'web.mcpDetected': 'Detected',
+  'web.mcpNotDetected': 'Available',
+  'web.mcpAlreadyConfigured': 'Configured',
+  'web.mcpSuccess': 'Successfully configured MCP in: {agents}',
+  'web.mcpSaveBtn': 'Save & Configure',
+
+  // CLI Slash Commands
+  'cli.menuTitle': 'Select a command:',
+  'cli.cmdLoadDesc': 'Tune and load a model with optimal hardware settings',
+  'cli.cmdMcpDesc': 'Connect local engine to AI coding agents as MCP server',
+  'cli.cmdPresetsDesc': 'View saved tuning presets',
+  'cli.cmdSettingsDesc': 'Configure interface language and visual theme',
+  'cli.cmdHelpDesc': 'View usage help and CLI flags',
+  'cli.cmdExitDesc': 'Exit',
+  'cli.mcpSelectEngine': 'Which engine do you want to configure as an MCP server?',
+  'cli.mcpSelectAgents': 'Select AI agents to configure (space to toggle, enter to confirm):',
+  'cli.mcpServerNamePrompt': 'MCP server name:',
+  'cli.mcpNoAgentsSelected': 'No agents selected. Exiting.',
+  'cli.mcpSuccess': "Configured MCP server '{server}' in: {agents}",
+  'cli.mcpFailed': 'Failed to configure MCP in: {agents}',
+  'cli.mcpStatusInstalled': 'Installed',
+  'cli.mcpStatusDetected': 'Detected',
+  'cli.mcpStatusAvailable': 'Available',
 };