llm-tuner 0.3.0 → 0.4.1

package/README.es.md

@@ -41,6 +41,7 @@ Ningún LLM decide la configuración. LLM Tuner lee la topología de tu hardware
 - **Soporte de motores locales**: Compatibilidad directa con LM Studio (a través de `llama-server`) y Ollama (instancias privadas aisladas).
 - **Presets persistentes**: Mide una única vez por combinación de hardware, modelo, contexto y perfil. Invalida presets automáticamente si el hardware o el archivo del modelo cambian.
 - **Doble interfaz**: Asistente en consola (`llm-tuner`) y aplicación gráfica de escritorio (`llm-tuner-desktop`).
+- **Integración MCP para agentes de IA**: Conecta tus motores locales (LM Studio, Ollama) como servidores Model Context Protocol (MCP) en Claude Desktop, Claude Code, OpenCode, Antigravity, VS Code y ChatGPT/Codex con nombres personalizados y seguridad multiplataforma.
 - **Bilingüe**: Localización completa en español e inglés tanto en terminal como en entorno gráfico.
 
 ---
@@ -93,15 +94,30 @@ Requisitos previos:
 
 ## Uso
 
-### Asistente interactivo
+### CLI interactiva y comandos slash
 
-Ejecuta el asistente en la terminal:
+Ejecuta la interfaz en la terminal:
 
 ```bash
 llm-tuner
 ```
 
-Te guiará paso a paso en la selección de motor, modelo, contexto, perfil recomendado y carga afinada.
+Ejecutar `llm-tuner` sin argumentos abre un menú interactivo para seleccionar la acción deseada:
+- `/load`: Ajustar y cargar un modelo con la configuración óptima para tu hardware
+- `/mcp`: Conectar tu motor local como servidor MCP con agentes de IA (Claude, OpenCode, VS Code, Codex)
+- `/presets`: Listar e inspeccionar los presets guardados
+- `/settings`: Configurar idioma (`en` / `es`) y tema visual (`system` / `light` / `dark`)
+- `/help`: Mostrar ayuda y opciones de uso
+- `/exit`: Salir del menú
+
+También puedes ejecutar cualquier comando slash directamente desde tu terminal:
+
+```bash
+llm-tuner /load
+llm-tuner /mcp
+llm-tuner /presets
+llm-tuner /settings
+```
 
 ### Aplicación de escritorio
 

package/README.md

@@ -41,6 +41,7 @@ No LLM decides the configuration. LLM Tuner reads your hardware topology and mod
 - **Engine Support**: First-class support for both LM Studio (direct `llama-server` management) and Ollama (isolated private benchmarks).
 - **Persistent Presets**: Measures once per hardware, model, context, and profile. Automatically invalidates presets if hardware or model weights change.
 - **Dual Interfaces**: Interactive terminal wizard (`llm-tuner`) and cross-platform desktop UI (`llm-tuner-desktop`).
+- **AI Agent MCP Integration**: Connect your local engines (LM Studio, Ollama) as Model Context Protocol (MCP) servers to Claude Desktop, Claude Code, OpenCode, Antigravity, VS Code, and ChatGPT/Codex with custom naming and cross-platform safety.
 - **Bilingual**: Full English and Spanish localization for both terminal and desktop interfaces.
 
 ---
@@ -93,15 +94,30 @@ Prerequisites:
 
 ## Usage
 
-### Interactive Wizard
+### Interactive CLI & Slash Commands
 
-Launch the terminal wizard:
+Launch the terminal interface:
 
 ```bash
 llm-tuner
 ```
 
-Guides you interactively through engine selection, model selection, context length, profile recommendation, and automatic tuning.
+Running `llm-tuner` without arguments presents an interactive menu to choose a command:
+- `/load`: Tune and load a model with optimal hardware settings
+- `/mcp`: Connect your local engine as an MCP server to AI agents (Claude, OpenCode, VS Code, Codex)
+- `/presets`: Inspect saved tuning presets
+- `/settings`: Configure language (`en` / `es`) and visual theme (`system` / `light` / `dark`)
+- `/help`: Display help and usage options
+- `/exit`: Exit the interactive menu
+
+You can also run any slash command directly from your terminal:
+
+```bash
+llm-tuner /load
+llm-tuner /mcp
+llm-tuner /presets
+llm-tuner /settings
+```
 
 ### Desktop App
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "llm-tuner",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "description": "Detects your hardware and finds the fastest configuration to run local LLMs with LM Studio or Ollama.",
   "keywords": [
     "llm",

package/src/cli/animation.js

@@ -0,0 +1,85 @@
+export class TerminalAnimation {
+  constructor(colors, isTTY = true) {
+    this.c = colors;
+    this.isTTY = Boolean(isTTY);
+    this.frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+    this.frameIdx = 0;
+    this.timer = null;
+    this.statusText = '';
+    this.pct = 0;
+    this.telemetry = null;
+    this.isActive = false;
+  }
+
+  start(initialStatus = '') {
+    if (!this.isTTY) return;
+    this.statusText = initialStatus;
+    this.isActive = true;
+    this.timer = setInterval(() => {
+      this.tick();
+    }, 80);
+    this.timer?.unref?.();
+  }
+
+  updateStatus(text) {
+    this.statusText = text || '';
+    this.tick();
+  }
+
+  updateProgress(pct) {
+    this.pct = Math.min(100, Math.max(0, pct ?? 0));
+    this.tick();
+  }
+
+  updateTelemetry(telem) {
+    this.telemetry = telem;
+    this.tick();
+  }
+
+  clear() {
+    if (this.isTTY && this.isActive) {
+      process.stdout.write('\r\x1b[K');
+    }
+  }
+
+  tick() {
+    if (!this.isTTY || !this.isActive) return;
+    const frame = this.frames[(this.frameIdx++) % this.frames.length];
+
+    const barLen = 16;
+    const filled = Math.round((this.pct / 100) * barLen);
+    const bar = this.c.cyan('━'.repeat(filled)) + this.c.dim('─'.repeat(barLen - filled));
+
+    let telemStr = '';
+    if (this.telemetry) {
+      if (this.telemetry.cpu) {
+        telemStr += ` · CPU ${this.telemetry.cpu.percent}%`;
+      }
+      if (this.telemetry.ram) {
+        const used = (this.telemetry.ram.usedBytes / 1024 ** 3).toFixed(1);
+        const total = (this.telemetry.ram.totalBytes / 1024 ** 3).toFixed(1);
+        telemStr += ` · RAM ${used}/${total} GB`;
+      }
+      if (this.telemetry.gpus?.length) {
+        telemStr += ' · ' + this.telemetry.gpus.map((g) => {
+          const used = (g.usedBytes / 1024 ** 3).toFixed(1);
+          const total = (g.totalBytes / 1024 ** 3).toFixed(1);
+          return `GPU${g.index} ${used}/${total} GB`;
+        }).join(' ');
+      }
+    }
+
+    const statusPart = this.statusText ? `${this.statusText} ` : '';
+    const line = `  ${this.c.cyan(frame)} ${statusPart}[${bar}] ${String(this.pct).padStart(3)}%${this.c.dim(telemStr)}`;
+    process.stdout.write(`\r\x1b[K${line}`);
+  }
+
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    this.clear();
+    this.isActive = false;
+  }
+}

package/src/cli/colors.js

@@ -0,0 +1,12 @@
+export function getColors(theme = 'dark') {
+  const isLight = theme === 'light';
+  return {
+    b: (s) => `\x1b[1m${s}\x1b[0m`,
+    dim: (s) => isLight ? `\x1b[90m${s}\x1b[0m` : `\x1b[2m${s}\x1b[0m`,
+    g: (s) => isLight ? `\x1b[38;2;40;138;0m${s}\x1b[0m` : `\x1b[38;2;101;255;0m${s}\x1b[0m`,
+    y: (s) => isLight ? `\x1b[33m${s}\x1b[0m` : `\x1b[93m${s}\x1b[0m`,
+    r: (s) => isLight ? `\x1b[38;2;214;21;0m${s}\x1b[0m` : `\x1b[38;2;255;26;0m${s}\x1b[0m`,
+    cyan: (s) => isLight ? `\x1b[38;2;0;124;153m${s}\x1b[0m` : `\x1b[38;2;0;229;255m${s}\x1b[0m`,
+    purple: (s) => isLight ? `\x1b[38;2;120;0;199m${s}\x1b[0m` : `\x1b[38;2;154;0;255m${s}\x1b[0m`,
+  };
+}

package/src/cli/commands/help.js

@@ -0,0 +1,7 @@
+import { presetsDir } from '../../core/index.js';
+import { t as translate } from '../../i18n/index.js';
+
+export async function helpCommand(args, { lang }) {
+  const t = (key, params) => translate(lang, key, params);
+  console.log(t('cli.help', { presetsDir: presetsDir() }));
+}

package/src/cli/commands/load.js

@@ -0,0 +1,338 @@
+import { select, input, confirm, search, Separator } from '@inquirer/prompts';
+import {
+  detectHardware,
+  detectEngines,
+  Tuner,
+  installPlans,
+  runInstall,
+  listPresets,
+  fmtBytes,
+  readSettings,
+  writeSettings,
+  DEFAULT_PROFILE,
+  TunerError,
+  checkUpdate,
+} from '../../core/index.js';
+import { t as translate } from '../../i18n/index.js';
+import { profileChoices, profileNotes, profileSwitchNote, profileEventLines, shouldAskProfile, parseContext } from '../profile.js';
+import { getColors } from '../colors.js';
+import { withNav, NAV_BACK, backChoice } from '../nav.js';
+import { TerminalAnimation } from '../animation.js';
+
+export async function loadCommand(args, { lang, theme }) {
+  const c = getColors(theme);
+  const t = (key, params) => translate(lang, key, params);
+
+  const describe = (cand) => {
+    const where = cand.fullOffload ? t('candidate.allGpu') : t('candidate.layersGpu', { gpu: cand.gpuLayers, total: cand.totalLayers });
+    return `KV ${cand.kvType} · ${where}${cand.cpuMoeLayers ? t('candidate.expertsRam', { layers: cand.cpuMoeLayers }) : ''}${t('candidate.threads', { n: cand.threads })}${cand.probe ? t('candidate.probe') : ''}`;
+  };
+
+  const benchErrorText = (b) => {
+    return b.errorCode ? t(b.errorCode, b.errorParams) : b.error;
+  };
+
+  const vramStr = (peaks = {}) => {
+    const e = Object.entries(peaks || {});
+    return e.length ? e.map(([i, b]) => `GPU${i} ${(b / 1024 ** 3).toFixed(1)} GB`).join(' / ') : t('common.na');
+  };
+
+  const updatePromise = checkUpdate().catch(() => null);
+  const isTTY = Boolean(process.stdout.isTTY && !args.json);
+  const anim = new TerminalAnimation(c, isTTY);
+
+  const out = (...a) => {
+    if (args.json) return;
+    anim.clear();
+    console.log(...a);
+  };
+
+  out([
+    '',
+    `  ${c.cyan('  ╭───')}${c.dim('╷ ╷ ╷')}${c.cyan('───╮')}`,
+    `  ${c.cyan('╭─┤  ')}${c.cyan('┌───┐')}${c.cyan('  ├─╮  ')}${c.b('LLM Tuner')}`,
+    `  ${c.cyan('│ ')}${c.dim('╶┤')}${c.b(' │ █ │ ')}${c.dim('├╴')}${c.cyan('▲ │  ')}${c.dim(t('web.tagline'))}`,
+    `  ${c.cyan('╰─┤  ')}${c.cyan('└───┘')}${c.cyan('  ├──╯')}`,
+    `  ${c.cyan('  ╰───')}${c.dim('╵ ╵ ╵')}${c.cyan('───╯')}`,
+    '',
+  ].join('\n'));
+
+  const updateInfo = await updatePromise;
+  if (updateInfo?.updateAvailable) {
+    out(c.y(`  ▲ ${t('cli.updateAvailable', { current: updateInfo.currentVersion, latest: updateInfo.latestVersion })}`));
+    out(c.dim(`    ${t('cli.updateCommand', { cmd: 'npm install -g llm-tuner' })}\n`));
+  }
+
+  const hw = await detectHardware();
+  out(c.dim(`  ${hw.cpu.brand} · ${fmtBytes(hw.ram.totalBytes)} RAM`));
+  for (const g of hw.gpus) out(c.dim(`  GPU${g.index} ${g.name} · ${fmtBytes(g.totalBytes)}${g.pcieGen ? ` · PCIe ${g.pcieGen}.0 x${g.pcieWidth}` : ''}${g.displayAttached ? t('cli.display') : ''}`));
+  if (!hw.gpus.length) out(c.y(`  ${t('cli.noGpu')}`));
+
+  let det = await detectEngines(hw);
+  let engineId = args.engine;
+  let tuner = null;
+  let models = [];
+  let modelKey = args.model;
+  let ctx = parseContext(args.ctx);
+  let profile = args.profile;
+
+  let currentStep = 1;
+
+  while (currentStep >= 1 && currentStep <= 4) {
+    if (currentStep === 1) {
+      if (args.engine) {
+        engineId = args.engine;
+        currentStep = 2;
+        continue;
+      }
+
+      const res = await withNav(() => select({
+        message: t('cli.whichEngine'),
+        default: det.recommended,
+        choices: [
+          ...det.engines.map((e) => ({
+            name: `${e.name}  ${e.detection.installed ? c.g(t('cli.installed')) + (e.detection.version ? c.dim(' v' + e.detection.version) : '') : c.dim(t('cli.notInstalled'))}${e.id === det.recommended ? c.y(`  ${t('cli.recommended')}`) : ''}`,
+            value: e.id,
+          })),
+          new Separator(),
+          backChoice(t, c),
+        ],
+      }));
+
+      if (res === NAV_BACK) return;
+      engineId = res;
+      currentStep = 2;
+    }
+    else if (currentStep === 2) {
+      if (!tuner || tuner.engine.id !== engineId) {
+        if (!det.engines.find((e) => e.id === engineId)?.detection.installed) {
+          await installFlow(engineId, { args, t, c });
+          det = await detectEngines(hw);
+          if (!det.engines.find((e) => e.id === engineId).detection.installed) throw new TunerError('errors.installNotFinished');
+        }
+        tuner = await Tuner.create(engineId);
+        models = await tuner.listModels();
+      }
+
+      if (args.model) {
+        modelKey = args.model;
+        currentStep = 3;
+        continue;
+      }
+
+      if (!models.length) {
+        out(c.y(`\n${t('cli.noModels', { engine: tuner.engine.name })}`));
+        const name = await input({ message: engineId === 'ollama' ? t('cli.downloadOllama') : t('cli.downloadLms') });
+        const bin = tuner.ctx.detection.bin;
+        const r = await runInstall(engineId === 'ollama' ? { cmd: bin, args: ['pull', name] } : { cmd: bin, args: ['get', name, '-y'] }, (l) => out(c.dim('  ' + l)));
+        if (r.code !== 0) throw new TunerError('errors.modelDownloadFailed');
+        models = await tuner.listModels();
+      }
+
+      const res = await withNav(() => search({
+        message: t('cli.model'),
+        source: (term) => [
+          backChoice(t, c),
+          new Separator(),
+          ...models
+            .filter((m) => !term || `${m.key} ${m.name}`.toLowerCase().includes(term.toLowerCase()))
+            .map((m) => ({ name: `${m.name}  ${c.dim(`${fmtBytes(m.sizeBytes)}${m.quant ? ' · ' + m.quant : ''}`)}`, value: m.key })),
+        ],
+      }));
+
+      if (res === NAV_BACK) {
+        if (args.engine) return;
+        currentStep = 1;
+        continue;
+      }
+
+      modelKey = res;
+      currentStep = 3;
+    }
+    else if (currentStep === 3) {
+      if (args.ctx) {
+        ctx = parseContext(args.ctx);
+        currentStep = 4;
+        continue;
+      }
+
+      const presets = await listPresets({ engine: engineId, modelKey });
+      const preview = await tuner.plan(modelKey, 8192);
+      const limit = preview.model.meta.trainContext || 131072;
+      const list = Object.entries(preview.maxContext).map(([k, v]) => `KV ${k} ${v ? Math.floor(v / 1024) + 'K' : '—'}`).join(' · ');
+      out(c.dim(`  ${t('cli.maxFullGpu', { list, train: Math.floor(limit / 1024) })}`));
+      if (presets.length) out(c.dim(`  ${t('cli.tunedContexts', { list: presets.map((p) => `${p.ctx / 1024}K (${p.shortTps} t/s)`).join(', ') })}`));
+
+      let inputBuffer = '';
+      const res = await withNav(() => input({
+        message: `${t('cli.context')} ${c.dim(`(Backspace: ${t('common.back')})`)}`,
+        default: String(presets.at(-1)?.ctx || Math.min(16384, limit)),
+        validate: (v) => {
+          inputBuffer = v;
+          if (v.toLowerCase() === 'b' || v.toLowerCase() === 'back') return true;
+          return parseContext(v, limit) !== null || t('cli.contextRange', { limit });
+        },
+      }), { isTextInput: true, getInputValue: () => inputBuffer });
+
+      if (res === NAV_BACK || res?.toLowerCase?.() === 'b' || res?.toLowerCase?.() === 'back') {
+        if (args.model) {
+          if (args.engine) return;
+          currentStep = 1;
+        } else {
+          currentStep = 2;
+        }
+        continue;
+      }
+
+      ctx = parseContext(res, limit);
+      currentStep = 4;
+    }
+    else if (currentStep === 4) {
+      if (args.profile || !shouldAskProfile(args)) {
+        profile = args.profile || DEFAULT_PROFILE;
+        break;
+      }
+
+      const plan = await tuner.profilePlan(modelKey, ctx);
+      const { profile: stored } = await readSettings();
+      for (const line of profileNotes(plan, t)) {
+        out((line.level === 'warn' ? c.y : c.dim)(`  ${line.text}`));
+      }
+
+      const choicesObj = profileChoices(plan, t, { stored, mark: c.y, dim: c.dim });
+      const res = await withNav(() => select({
+        message: t('cli.profile'),
+        ...choicesObj,
+        choices: [
+          ...choicesObj.choices,
+          new Separator(),
+          backChoice(t, c),
+        ],
+      }));
+
+      if (res === NAV_BACK) {
+        if (args.ctx) {
+          if (args.model) {
+            if (args.engine) return;
+            currentStep = 1;
+          } else {
+            currentStep = 2;
+          }
+        } else {
+          currentStep = 3;
+        }
+        continue;
+      }
+
+      profile = res;
+      try {
+        await writeSettings({ profile });
+      } catch (e) {
+        console.error(c.y(t('cli.profileNotSaved', { error: e.message })));
+      }
+      const switchNote = profileSwitchNote(plan, profile, t, tuner.engine.name);
+      if (switchNote) out(c.dim(`  ${switchNote}`));
+      break;
+    }
+  }
+
+  // 5. Load & Benchmark Execution with Desktop-style live animation
+  if (!tuner) {
+    tuner = await Tuner.create(engineId);
+  }
+
+  const advisedByWizard = !args.profile;
+  let previous = null;
+
+  anim.start(t('status.loading'));
+
+  tuner.on('progress', (e) => {
+    if (args.json) return;
+
+    if (e.type === 'telemetry') {
+      anim.updateTelemetry(e);
+      return;
+    }
+    if (e.progress) {
+      anim.updateProgress(e.progress.pct);
+    }
+    if (e.type === 'variant-picked' || e.type === 'profile-fallback') {
+      for (const line of profileEventLines(e, previous, t, advisedByWizard ? null : tuner.engine.name)) {
+        out((line.level === 'warn' ? c.y : c.dim)(`  ${line.text}`));
+      }
+    }
+    previous = e;
+    if (e.type === 'status') {
+      anim.updateStatus(t(e.code, e.params));
+      out(c.dim(`\n${t(e.code, e.params)}`));
+    }
+    if (e.type === 'preset-hit') {
+      out(c.g(`\n✓ ${t('cli.presetHit', { date: e.preset.createdAt.slice(0, 10), config: describe(e.preset.candidate), tps: e.preset.bench.short.genTps })}`));
+    }
+    if (e.type === 'candidate-start') {
+      anim.updateStatus(`[${e.index + 1}/${e.total}] ${describe(e.candidate)}`);
+      out(`  [${e.index + 1}/${e.total}] ${describe(e.candidate)}`);
+    }
+    if (e.type === 'bench-progress' && e.phase === 'deep') {
+      out(c.dim(`      ${t('common.longPrompt', { tokens: e.promptTokens })}`));
+    }
+    if (e.type === 'candidate-done') {
+      const b = e.bench;
+      out(b.ok
+        ? `      ${c.g('✓')} ${t('cli.benchShort', { tps: c.b(b.short.genTps + ' t/s') })}${b.deep ? t('cli.benchDeep', { tps: c.b(b.deep.genTps + ' t/s'), tokens: b.deep.promptTokens }) : ''} · CPU ${b.cpu.avg}% · VRAM ${vramStr(b.vramPeakBytes)}`
+        : c.r(`      ✗ ${benchErrorText(b)}`));
+    }
+    if (e.type === 'preset-saved') {
+      out(c.g(`\n✓ ${t('common.presetSaved', { file: e.file })}`));
+    }
+  });
+
+  let result;
+  try {
+    result = await tuner.load(modelKey, ctx, {
+      profile,
+      force: !!args.force,
+      dryRun: !!args['dry-run'],
+      maxCandidates: Number(args.candidates) || 3,
+      confirmApply: async (preview) => {
+        anim.stop();
+        out(c.b(`\n${t('cli.changes')}`));
+        if (engineId === 'lmstudio') {
+          preview.files.forEach((f) => out(`  ${f}`));
+          if (preview.restartsApp) out(c.y(`  ${t('cli.lmsRestart')}`));
+        } else {
+          out(`  ${t('cli.ollamaNewModel', { name: c.b(preview.tunedModel) })}`);
+          out(`  ${t('cli.ollamaServer', { env: Object.entries(preview.env).map(([k, v]) => `${k}=${v}`).join(' ') })}`);
+        }
+        const confirmed = args.yes || await confirm({ message: t('cli.confirmApply'), default: true });
+        if (confirmed) anim.start(t('status.applying'));
+        return confirmed;
+      },
+    });
+  } finally {
+    anim.stop();
+  }
+
+  if (args['dry-run']) out(c.y(`\n${t('cli.dryRun')}`));
+  if (result.applied?.backups?.length) out(c.dim(`  ${t('common.backups', { list: result.applied.backups.join(', ') })}`));
+  if (result.applied?.pendingCommands?.length) {
+    out(c.y(`\n${t('cli.pending')}`));
+    result.applied.pendingCommands.forEach((cmd) => out(`  ${cmd}`));
+  }
+  const l = result.loaded;
+  if (l) out(l.ok
+    ? c.g(`\n✓ ${t('cli.loaded', { engine: tuner.engine.name, tps: c.b(l.short.genTps + ' t/s') })}${l.model ? t('cli.usesModel', { model: l.model }) : ''}`)
+    : c.r(`\n✗ ${t('cli.loadFailed', { error: benchErrorText(l) })}`));
+  if (args.json) console.log(JSON.stringify(result, null, 2));
+}
+
+async function installFlow(engineId, { args, t, c }) {
+  const plans = await installPlans(engineId);
+  if (!plans.length) throw new TunerError('errors.noInstaller');
+  const plan = plans.length === 1 ? plans[0] : await select({ message: t('cli.installMethod'), choices: plans.map((p) => ({ name: t(p.labelCode), value: p })) });
+  console.log(c.dim(`  ${plan.shell || (plan.cmd ? [plan.cmd, ...plan.args].join(' ') : plan.url)}`));
+  if (!args.yes && !(await confirm({ message: t('cli.installNow'), default: true }))) process.exit(0);
+  const r = await runInstall(plan, (l) => console.log(c.dim('  ' + l)));
+  if (r.manual) await input({ message: t('cli.installManual') });
+  else if (r.code !== 0) throw new TunerError('errors.installerExit', { code: r.code });
+}

package/src/cli/commands/mcp.js

@@ -0,0 +1,118 @@
+import { select, checkbox, input, Separator } from '@inquirer/prompts';
+import { detectHardware, detectEngines, detectAgents, installMcpServer } from '../../core/index.js';
+import { t as translate } from '../../i18n/index.js';
+import { getColors } from '../colors.js';
+import { withNav, NAV_BACK, backChoice } from '../nav.js';
+
+export async function mcpCommand(args, { lang, theme }) {
+  const c = getColors(theme);
+  const t = (key, params) => translate(lang, key, params);
+
+  let step = 1;
+  let engineId = args.engine;
+  let selectedAgents = [];
+  let customName = args.name;
+  let agents = null;
+
+  while (step >= 1 && step <= 3) {
+    if (step === 1) {
+      if (args.engine) {
+        step = 2;
+        continue;
+      }
+      const hw = await detectHardware();
+      const det = await detectEngines(hw);
+      const res = await withNav(() => select({
+        message: t('cli.mcpSelectEngine'),
+        default: det.recommended || 'lmstudio',
+        choices: [
+          { name: 'LM Studio', value: 'lmstudio' },
+          { name: 'Ollama', value: 'ollama' },
+          new Separator(),
+          backChoice(t, c),
+        ],
+      }));
+      if (res === NAV_BACK) return;
+      engineId = res;
+      step = 2;
+    }
+    else if (step === 2) {
+      if (!agents) {
+        agents = await detectAgents();
+      }
+      const res = await withNav(() => checkbox({
+        message: `${t('cli.mcpSelectAgents')} ${c.dim(`(Backspace: ${t('common.back')})`)}`,
+        choices: agents.map((agent) => {
+          const isConfigured = agent.configuredServers?.includes(engineId);
+          let statusStr = agent.detected ? c.g(`[${t('cli.mcpStatusDetected')}]`) : c.dim(`[${t('cli.mcpStatusAvailable')}]`);
+          if (isConfigured) {
+            statusStr += ` ${c.cyan(`(${t('web.mcpAlreadyConfigured')})`)}`;
+          }
+          return {
+            name: `${agent.name.padEnd(18)} ${statusStr}`,
+            value: agent.id,
+            checked: agent.detected,
+          };
+        }),
+      }));
+      if (res === NAV_BACK) {
+        if (args.engine) return;
+        step = 1;
+        continue;
+      }
+      if (!res.length) {
+        console.log(c.y(t('cli.mcpNoAgentsSelected')));
+        return;
+      }
+      selectedAgents = res;
+      step = 3;
+    }
+    else if (step === 3) {
+      if (args.name) {
+        customName = args.name;
+        break;
+      }
+      let buffer = '';
+      const res = await withNav(() => input({
+        message: `${t('cli.mcpServerNamePrompt')} ${c.dim(`(Backspace: ${t('common.back')})`)}`,
+        default: engineId,
+        validate: (val) => {
+          buffer = val;
+          if (val.toLowerCase() === 'b' || val.toLowerCase() === 'back') return true;
+          return Boolean(val.trim()) || 'Server name cannot be empty';
+        },
+      }), { isTextInput: true, getInputValue: () => buffer });
+
+      if (res === NAV_BACK || res?.toLowerCase?.() === 'b' || res?.toLowerCase?.() === 'back') {
+        step = 2;
+        continue;
+      }
+      customName = res.trim();
+      break;
+    }
+  }
+
+  // Install MCP server configuration
+  const result = await installMcpServer({
+    engineId,
+    customName,
+    agentIds: selectedAgents,
+    host: args.host,
+    apiKey: args.apiKey,
+  });
+
+  // Report results
+  if (result.updated.length) {
+    const updatedNames = result.updated
+      .map((id) => agents?.find((a) => a.id === id)?.name || id)
+      .join(', ');
+    console.log(c.g(`\n✓ ${t('cli.mcpSuccess', { server: customName, agents: updatedNames })}`));
+  }
+
+  if (result.errors?.length) {
+    const errDetails = result.errors
+      .map((e) => `${agents?.find((a) => a.id === e.agentId)?.name || e.agentId}: ${e.error}`)
+      .join(', ');
+    console.error(c.r(`\n✗ ${t('cli.mcpFailed', { agents: errDetails })}`));
+  }
+}

package/src/cli/commands/presets.js

@@ -0,0 +1,21 @@
+import { listPresets } from '../../core/index.js';
+import { t as translate } from '../../i18n/index.js';
+import { getColors } from '../colors.js';
+
+export async function presetsCommand(args, { lang, theme }) {
+  const c = getColors(theme);
+  const t = (key, params) => translate(lang, key, params);
+
+  const list = await listPresets({ engine: args.engine, modelKey: args.model });
+  if (!list.length) {
+    console.log(t('cli.noPresets'));
+    return;
+  }
+
+  for (const p of list) {
+    const profileStr = p.profile ? `  ${p.profile}${p.variant && p.variant !== p.model ? ` (${p.variant})` : ''}` : '';
+    const offloadStr = p.fullOffload ? t('candidate.allGpu') : t('cli.partial');
+    const dateStr = c.dim(p.createdAt.slice(0, 16).replace('T', ' '));
+    console.log(`${p.engine.padEnd(9)} ${p.model}  ${p.ctx / 1024}K${profileStr}  KV ${p.kvType}  ${offloadStr}  ${p.shortTps} t/s  ${dateStr}`);
+  }
+}