llm-tuner 0.3.0 → 0.4.1

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/engines/lmstudio.js

@@ -170,9 +170,10 @@ export const lmstudio = {
 
   async benchmarkViaLms(ctx, model, candidate, opts) {
     const bin = ctx.detection.bin;
-    const restore = await this.writeModelConfig(ctx, model.key, candidate);
+    const modelKey = model.key || model;
+    const restore = await this.writeModelConfig(ctx, modelKey, candidate, model.meta);
     try {
-      const args = ['load', model.key, '-y', '--identifier', 'llm-tuner-bench', '-c', String(candidate.ctx), '--gpu', candidate.fullOffload ? 'max' : String(candidate.gpuLayers / candidate.totalLayers)];
+      const args = ['load', modelKey, '-y', '--identifier', 'llm-tuner-bench', '-c', String(candidate.ctx), '--gpu', candidate.fullOffload ? 'max' : String(candidate.gpuLayers / candidate.totalLayers)];
       const r = await run(bin, args, { timeout: 600_000 });
       if (r.code !== 0) return { ok: false, error: (r.stderr || r.stdout).slice(-400) };
       return await runApiBenchmark({ kind: 'lmstudio', baseUrl: 'http://127.0.0.1:1234', model: 'llm-tuner-bench', ...opts });
@@ -182,17 +183,52 @@ export const lmstudio = {
     }
   },
 
-  configPaths(ctx, key) {
+  /** Resolve the concrete indexedModelIdentifier for a given key or file. */
+  async resolveConcreteIdentifier(ctx, key, meta) {
+    if (!key) return key;
+    if (key.includes('/') && key.endsWith('.gguf')) return key;
+    const home = ctx.detection?.home || (await lmsHome());
+    const idx = await readJson(path.join(home, '.internal', 'model-index-cache.json'), { models: [] });
+    const entries = idx.models || [];
+    const byId = (id) => entries.find((e) => e.indexedModelIdentifier === id && !e.virtual);
+    let entry = null;
+    if (meta?.file) {
+      entry = entries.find((e) => e.entryPoint?.absPath === meta.file || (e.concreteModelDirAbsolutePath && meta.file.startsWith(e.concreteModelDirAbsolutePath)));
+    }
+    if (!entry) {
+      entry = entries.find((e) => e.indexedModelIdentifier === key || e.defaultIdentifier === key || e.virtual?.baseChain?.[0] === key);
+    }
+    const concrete = entry?.virtual?.concreteModelIndexedModelIdentifier || entry?.virtual?.baseChain?.at?.(-1);
+    if (concrete) entry = byId(concrete) || entry;
+    if (entry?.indexedModelIdentifier) return entry.indexedModelIdentifier;
+    if (entry?.entryPoint?.relPath) return entry.entryPoint.relPath;
+    if (ctx.detection?.bin) {
+      const r = await run(ctx.detection.bin, ['ls', '--json']);
+      if (r.code === 0) {
+        try {
+          const list = JSON.parse(r.stdout);
+          const found = (Array.isArray(list) ? list : []).find((m) => m && (m.modelKey === key || m.path === key || m.indexedModelIdentifier === key));
+          if (found?.indexedModelIdentifier || found?.path) return found.indexedModelIdentifier || found.path;
+        } catch { /* ignore */ }
+      }
+    }
+    return key;
+  },
+
+  async configPaths(ctx, key, meta) {
     const internal = path.join(ctx.detection.home, '.internal');
+    const concrete = key ? await this.resolveConcreteIdentifier(ctx, key, meta) : '';
     return {
-      modelConfig: path.join(internal, 'user-concrete-model-default-config', `${key}.json`),
+      modelConfig: path.join(internal, 'user-concrete-model-default-config', `${concrete || key}.json`),
+      aliasConfig: concrete && concrete !== key ? path.join(internal, 'user-concrete-model-default-config', `${key}.json`) : null,
       hardwareConfig: path.join(internal, 'hardware-config.json'),
     };
   },
 
-  async writeModelConfig(ctx, key, c) {
-    const file = this.configPaths(ctx, key).modelConfig;
-    const cur = (await readJson(file)) || { preset: '', operation: { fields: [] }, load: { fields: [] } };
+  async writeModelConfig(ctx, key, c, meta) {
+    const paths = await this.configPaths(ctx, key, meta);
+    const file = paths.modelConfig;
+    const cur = (await readJson(file)) || (paths.aliasConfig ? (await readJson(paths.aliasConfig)) : null) || { preset: '', operation: { fields: [] }, load: { fields: [] } };
     const fields = new Map((cur.load?.fields || []).map((f) => [f.key, f.value]));
     const set = (k, v) => fields.set(k, v);
     set('llm.load.contextLength', c.ctx);
@@ -207,15 +243,24 @@ export const lmstudio = {
     set('llm.load.llama.kCacheQuantizationType', { checked: c.kvType !== 'f16', value: c.kvType });
     set('llm.load.llama.vCacheQuantizationType', { checked: c.kvType !== 'f16', value: c.kvType });
     if (c.cpuMoeLayers) set('llm.load.numCpuExpertLayersRatio', +(c.cpuMoeLayers / (c.totalLayers - 1)).toFixed(3));
-    const next = { ...cur, load: { ...(cur.load || {}), fields: [...fields].map(([key, value]) => ({ key, value })) } };
-    if (JSON.stringify(next) === JSON.stringify(cur)) return { file, backup: null, unchanged: true };
+    const next = { ...cur, load: { ...(cur.load || {}), fields: [...fields].map(([k, value]) => ({ key: k, value })) } };
+    const fileExists = await exists(file);
+    if (fileExists && JSON.stringify(next) === JSON.stringify(cur)) {
+      if (paths.aliasConfig && !(await exists(paths.aliasConfig))) {
+        await writeJsonWithBackup(paths.aliasConfig, next).catch(() => null);
+      }
+      return { file, backup: null, unchanged: true };
+    }
     const backup = await writeJsonWithBackup(file, next);
+    if (paths.aliasConfig) {
+      await writeJsonWithBackup(paths.aliasConfig, next).catch(() => null);
+    }
     return { file, backup };
   },
 
   /** hardware-config.json is superjson: {"json":[[backendName,{fields:[...]}]],"meta":{...}} */
   async writeHardwareConfig(ctx, c) {
-    const file = this.configPaths(ctx, '').hardwareConfig;
+    const file = (await this.configPaths(ctx, '')).hardwareConfig;
     const be = await this.backend(ctx);
     const backendName = be?.name || 'llama.cpp';
     const cur = (await readJson(file)) || { json: [], meta: { values: ['map'] } };
@@ -269,7 +314,7 @@ export const lmstudio = {
 
   /** Does hardware-config.json already match what this candidate needs? */
   async isHardwareApplied(ctx, c) {
-    const file = this.configPaths(ctx, '').hardwareConfig;
+    const file = (await this.configPaths(ctx, '')).hardwareConfig;
     const be = await this.backend(ctx);
     const cur = await readJson(file);
     const entry = (cur?.json || []).find(([name]) => name === (be?.name || 'llama.cpp'));
@@ -288,7 +333,8 @@ export const lmstudio = {
    * overwritten by the app on exit, so the app is closed while it changes.
    */
   async apply(ctx, model, c, { closeApp = true, relaunch = true, dryRun = false } = {}) {
-    const paths = this.configPaths(ctx, model.key);
+    const modelKey = model.key || model;
+    const paths = await this.configPaths(ctx, modelKey, model.meta);
     const hardwareOk = await this.isHardwareApplied(ctx, c);
     const det = await this.detect();
     const plan = { files: hardwareOk ? [paths.modelConfig] : [paths.modelConfig, paths.hardwareConfig], restartsApp: !hardwareOk && det.appRunning, candidate: c };
@@ -304,7 +350,7 @@ export const lmstudio = {
       if (b.backup) backups.push(b.backup);
       changes.push({ code: 'changes.lmsHardware' });
     }
-    const a = await this.writeModelConfig(ctx, model.key, c);
+    const a = await this.writeModelConfig(ctx, modelKey, c, model.meta);
     if (a.backup) backups.push(a.backup);
     if (!a.unchanged) changes.push(c.fullOffload
       ? { code: 'changes.lmsModelFull', params: { ctx: c.ctx, kvType: c.kvType, threads: c.threads } }
@@ -317,16 +363,23 @@ export const lmstudio = {
   },
 
   /** Load the model the normal way (using the saved config) and optionally measure it. */
-  async load(ctx, model, { depthTokens = 0, genTokens = 200, onProgress } = {}) {
+  async load(ctx, model, { candidate, depthTokens = 0, genTokens = 200, onProgress } = {}) {
     const bin = ctx.detection.bin;
     if (!bin) return benchError('bench.lmsUnavailable');
     await run(bin, ['server', 'start']);
     await run(bin, ['unload', '--all']);
     onProgress?.({ phase: 'load' });
-    const r = await run(bin, ['load', model.key, '-y'], { timeout: 600_000 });
+    const modelKey = model.key || model;
+    const args = ['load', modelKey, '-y'];
+    if (candidate?.ctx) args.push('-c', String(candidate.ctx));
+    if (candidate?.gpuLayers != null && candidate?.totalLayers) {
+      args.push('--gpu', candidate.fullOffload ? 'max' : String(+(candidate.gpuLayers / candidate.totalLayers).toFixed(3)));
+    }
+    if (candidate?.parallel) args.push('--parallel', String(candidate.parallel));
+    const r = await run(bin, args, { timeout: 600_000 });
     if (r.code !== 0) return { ok: false, error: (r.stderr || r.stdout).slice(-400) };
     const url = ctx.detection?.apiUrl || apiUrl();
-    return runApiBenchmark({ kind: 'lmstudio', baseUrl: url, model: model.key, depthTokens, genTokens, onProgress });
+    return runApiBenchmark({ kind: 'lmstudio', baseUrl: url, model: modelKey, depthTokens, genTokens, onProgress });
   },
 
   async chat(ctx, model, messages) {

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 };
+}