llm-tuner 0.2.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

@@ -9,4 +9,5 @@ export { findPreset, savePreset, listPresets, presetsDir, presetPath, variantsSi
 export { readSettings, writeSettings, settingsPath, THEMES, DEFAULT_THEME, normalizeTheme } from './settings.js';
 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/core/updater.js

@@ -0,0 +1,99 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { configDir, readJson, fetchJson } from './util.js';
+
+const pkgUrl = new URL('../../package.json', import.meta.url);
+const pkgContent = await fs.readFile(pkgUrl, 'utf8');
+export const CURRENT_VERSION = JSON.parse(pkgContent).version;
+
+export const DEFAULT_REGISTRY_URL = 'https://registry.npmjs.org/llm-tuner/latest';
+export const DEFAULT_CACHE_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
+
+export const updateCachePath = () => path.join(configDir(), 'update-check.json');
+
+/**
+ * Parse a semver string into [major, minor, patch] numbers.
+ * Strips any leading 'v' and ignores pre-release/build identifiers.
+ */
+export function parseSemver(v) {
+  if (typeof v !== 'string') return null;
+  const clean = v.trim().replace(/^v/, '');
+  const [core] = clean.split('-');
+  const parts = core.split('.').map((p) => Number(p));
+  if (parts.length < 3 || parts.some((n) => Number.isNaN(n) || n < 0)) return null;
+  return parts.slice(0, 3);
+}
+
+/**
+ * Returns true if `latest` is strictly newer than `current`.
+ */
+export function isNewerVersion(latest, current) {
+  const l = parseSemver(latest);
+  const c = parseSemver(current);
+  if (!l || !c) return false;
+  for (let i = 0; i < 3; i++) {
+    if (l[i] > c[i]) return true;
+    if (l[i] < c[i]) return false;
+  }
+  return false;
+}
+
+/**
+ * Checks npm registry for updates with a 24h cache.
+ * Never throws; returns safe fallback on network or file errors.
+ */
+export async function checkUpdate({
+  force = false,
+  timeout = 2000,
+  cacheTtlMs = DEFAULT_CACHE_TTL_MS,
+  registryUrl = DEFAULT_REGISTRY_URL,
+  currentVersion = CURRENT_VERSION,
+} = {}) {
+  try {
+    const cacheFile = updateCachePath();
+    if (!force) {
+      const cached = await readJson(cacheFile, null);
+      if (cached && typeof cached === 'object' && cached.lastChecked && cached.latestVersion) {
+        if (Date.now() - cached.lastChecked < cacheTtlMs) {
+          return {
+            updateAvailable: isNewerVersion(cached.latestVersion, currentVersion),
+            currentVersion,
+            latestVersion: cached.latestVersion,
+            cached: true,
+          };
+        }
+      }
+    }
+
+    const res = await fetchJson(registryUrl, { timeout });
+    if (res?.ok && res?.json?.version) {
+      const latest = res.json.version;
+      try {
+        await fs.mkdir(configDir(), { recursive: true });
+        await fs.writeFile(cacheFile, JSON.stringify({ lastChecked: Date.now(), latestVersion: latest }, null, 2));
+      } catch {
+        // Ignore cache write errors
+      }
+      return {
+        updateAvailable: isNewerVersion(latest, currentVersion),
+        currentVersion,
+        latestVersion: latest,
+        cached: false,
+      };
+    }
+
+    return {
+      updateAvailable: false,
+      currentVersion,
+      latestVersion: null,
+      cached: false,
+    };
+  } catch {
+    return {
+      updateAvailable: false,
+      currentVersion,
+      latestVersion: null,
+      cached: false,
+    };
+  }
+}