termsearch 0.3.0 → 0.3.2

package/README.md

@@ -1,6 +1,6 @@
 # TermSearch - Personal Search Engine
 
-[![Status](https://img.shields.io/badge/Status-0.3.0-blue.svg)](#project-status)
+[![Status](https://img.shields.io/badge/Status-0.3.2-blue.svg)](#project-status)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
 [![Node.js](https://img.shields.io/badge/Node.js-18%2B-green.svg)](https://nodejs.org)
 [![Target](https://img.shields.io/badge/Target-Termux%20%2F%20Linux%20%2F%20macOS-green.svg)](https://termux.dev)
@@ -12,7 +12,9 @@ Zero external dependencies, no Docker, no Python. AI is optional and configured
 Core capabilities:
 
 - Zero-config search via DuckDuckGo and Wikipedia — works immediately after install
+- Built-in GitHub Search API fallback (`github-api`) and selectable engine mix from UI
 - Progressive enhancement: add Brave/Mojeek API keys, AI endpoints, or SearXNG when needed
+- Search history persistence (opt-in toggle in Settings)
 - Social profile scanner: GitHub, Bluesky, Reddit, Twitter/X, Instagram, YouTube, LinkedIn, TikTok, Telegram, Facebook
 - Torrent search: The Pirate Bay + 1337x with direct magnet extraction
 - Social search: Bluesky posts/actors + GDELT news
@@ -22,7 +24,7 @@ Core capabilities:
 
 ## Project Status
 
-- Current line: `0.3.0`
+- Current line: `0.3.2`
 - Core is MIT — zero required API keys
 - AI features are optional, configured via Settings page in browser
 - Tested on: Ubuntu 24.04, Termux (Android 15/16)
@@ -89,8 +91,11 @@ Configure at **Settings → AI** in the browser. Supported endpoints:
 |----------|----------|-------|-----|
 | **Localhost** (Ollama) | `http://localhost:11434/v1` | `qwen3.5:4b` or any | not required |
 | **Localhost** (LM Studio) | `http://localhost:1234/v1` | your loaded model | not required |
+| **Localhost** (llama.cpp) | `http://localhost:8080/v1` | your loaded model | not required |
 | **Chutes.ai TEE** | `https://llm.chutes.ai/v1` | `deepseek-ai/DeepSeek-V3.2-TEE` | required |
+| **Anthropic** | `https://api.anthropic.com/v1` | `claude-3-5-haiku-latest` | required |
 | **OpenAI** | `https://api.openai.com/v1` | `gpt-4o-mini` | required |
+| **OpenRouter** | `https://openrouter.ai/api/v1` | any listed model | required |
 | **API custom** | any OpenAI-compatible URL | your model | optional |
 
 All providers use the OpenAI-compatible `/chat/completions` format. Leave API key empty for local models.
@@ -107,7 +112,7 @@ All providers use the OpenAI-compatible `/chat/completions` format. Leave API ke
 src/
   config/           config manager — load/save/defaults/env overrides
   search/
-    providers/      DuckDuckGo, Wikipedia, Brave, Mojeek, SearXNG
+    providers/      DuckDuckGo, Wikipedia, Brave, Mojeek, SearXNG, GitHub API
     engine.js       fan-out, merge, rank, cache
     ranking.js      source diversity ranking
     cache.js        tiered cache (L1 Map + L2 disk JSON)

package/bin/termsearch.js

@@ -32,7 +32,7 @@ function info(msg) { console.log(`  ${CYAN}→${RESET} ${msg}`); }
 
 // ─── Package version ──────────────────────────────────────────────────────
 
-let VERSION = '0.3.0';
+let VERSION = '0.3.1';
 try { VERSION = JSON.parse(readFileSync(PKG_PATH, 'utf8')).version || VERSION; } catch { /* ignore */ }
 
 // ─── Data dir + paths ─────────────────────────────────────────────────────

package/frontend/dist/app.js

@@ -16,6 +16,23 @@ const state = {
   loading: false,
   providers: [],
   config: null,
+  historyEnabled: localStorage.getItem('ts-save-history') !== '0',
+  selectedEngines: (() => {
+    try {
+      const raw = JSON.parse(localStorage.getItem('ts-engines') || '[]');
+      return Array.isArray(raw) ? raw.slice(0, 20).map((v) => String(v || '').trim().toLowerCase()).filter(Boolean) : [];
+    } catch {
+      return [];
+    }
+  })(),
+  searchHistory: (() => {
+    try {
+      const raw = JSON.parse(localStorage.getItem('ts-history') || '[]');
+      return Array.isArray(raw) ? raw.slice(0, 50).filter((q) => typeof q === 'string' && q.trim()) : [];
+    } catch {
+      return [];
+    }
+  })(),
 };
 
 function buildSearchHash(query, category = 'web') {
@@ -65,6 +82,64 @@ function toggleTheme() {
   localStorage.setItem('ts-theme', isLight ? 'light' : 'dark');
 }
 
+function setHistoryEnabled(enabled) {
+  state.historyEnabled = Boolean(enabled);
+  localStorage.setItem('ts-save-history', state.historyEnabled ? '1' : '0');
+  if (!state.historyEnabled) {
+    state.searchHistory = [];
+    localStorage.removeItem('ts-history');
+  }
+}
+
+function persistHistory() {
+  if (!state.historyEnabled) return;
+  localStorage.setItem('ts-history', JSON.stringify(state.searchHistory.slice(0, 50)));
+}
+
+function addSearchToHistory(query) {
+  const q = String(query || '').trim();
+  if (!q || !state.historyEnabled) return;
+  state.searchHistory = [q, ...state.searchHistory.filter((item) => item !== q)].slice(0, 50);
+  persistHistory();
+}
+
+const LANG_CANONICAL = new Map([
+  ['it', 'it-IT'], ['it-it', 'it-IT'],
+  ['en', 'en-US'], ['en-us', 'en-US'],
+  ['es', 'es-ES'], ['es-es', 'es-ES'],
+  ['fr', 'fr-FR'], ['fr-fr', 'fr-FR'],
+  ['de', 'de-DE'], ['de-de', 'de-DE'],
+  ['pt', 'pt-PT'], ['pt-pt', 'pt-PT'],
+  ['ru', 'ru-RU'], ['ru-ru', 'ru-RU'],
+  ['zh', 'zh-CN'], ['zh-cn', 'zh-CN'],
+  ['ja', 'ja-JP'], ['ja-jp', 'ja-JP'],
+]);
+
+function normalizeLangCode(raw) {
+  const key = String(raw || '').trim().toLowerCase();
+  return LANG_CANONICAL.get(key) || null;
+}
+
+function getResolvedLang() {
+  const selected = getLang();
+  if (selected && selected !== 'auto') return selected;
+  const browser = normalizeLangCode(navigator.language || navigator.languages?.[0] || '');
+  return browser || 'en-US';
+}
+
+function persistSelectedEngines() {
+  localStorage.setItem('ts-engines', JSON.stringify(state.selectedEngines.slice(0, 20)));
+}
+
+function setSelectedEngines(engines) {
+  state.selectedEngines = [...new Set(
+    (Array.isArray(engines) ? engines : [])
+      .map((engine) => String(engine || '').trim().toLowerCase())
+      .filter(Boolean)
+  )].slice(0, 20);
+  persistSelectedEngines();
+}
+
 // ─── SVG Icons ────────────────────────────────────────────────────────────
 function svg(paths, size = 16, extra = '') {
   return `<svg xmlns="http://www.w3.org/2000/svg" width="${size}" height="${size}" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" ${extra}>${paths}</svg>`;
@@ -124,6 +199,38 @@ const LANGS = [
   { code: 'ja-JP', label: '🇯🇵 JA' },
 ];
 
+const AI_PRESETS = [
+  { id: 'openai', label: 'OpenAI', api_base: 'https://api.openai.com/v1', keyRequired: true, defaultModel: 'gpt-4o-mini' },
+  { id: 'chutes', label: 'Chutes.ai', api_base: 'https://llm.chutes.ai/v1', keyRequired: true, defaultModel: 'deepseek-ai/DeepSeek-V3.2-TEE' },
+  { id: 'openrouter', label: 'OpenRoute/OpenRouter', api_base: 'https://openrouter.ai/api/v1', keyRequired: true, defaultModel: 'openai/gpt-4o-mini' },
+  { id: 'anthropic', label: 'Anthropic', api_base: 'https://api.anthropic.com/v1', keyRequired: true, defaultModel: 'claude-3-5-haiku-latest' },
+  { id: 'ollama', label: 'Ollama', api_base: 'http://127.0.0.1:11434/v1', keyRequired: false, defaultModel: 'qwen3.5:4b' },
+  { id: 'lmstudio', label: 'LM Studio', api_base: 'http://127.0.0.1:1234/v1', keyRequired: false, defaultModel: '' },
+  { id: 'llamacpp', label: 'llama.cpp server', api_base: 'http://127.0.0.1:8080/v1', keyRequired: false, defaultModel: '' },
+];
+
+const ENGINE_GROUPS = [
+  { label: 'Web Core', items: ['duckduckgo', 'wikipedia', 'brave', 'startpage', 'qwant', 'mojeek', 'bing', 'google', 'yahoo'] },
+  { label: 'Code & Dev', items: ['github', 'github-api', 'hackernews', 'reddit'] },
+  { label: 'Media', items: ['youtube', 'sepiasearch'] },
+  { label: 'Research', items: ['wikidata', 'crossref', 'openalex', 'openlibrary'] },
+  { label: 'Federated', items: ['mastodon users', 'mastodon hashtags', 'tootfinder', 'lemmy communities', 'lemmy posts'] },
+  { label: 'Torrent', items: ['piratebay', '1337x', 'nyaa'] },
+];
+
+const ENGINE_PRESETS = [
+  { id: 'all', label: 'All', engines: [] },
+  { id: 'balanced', label: 'Balanced', engines: ['duckduckgo', 'wikipedia', 'bing', 'startpage', 'github', 'reddit', 'youtube'] },
+  { id: 'github', label: 'GitHub Focus', engines: ['github-api', 'github', 'duckduckgo', 'wikipedia'] },
+];
+
+function detectPresetFromBase(base) {
+  const raw = String(base || '').toLowerCase();
+  if (!raw) return 'custom';
+  const preset = AI_PRESETS.find((p) => raw.startsWith(String(p.api_base).toLowerCase()));
+  return preset ? preset.id : 'custom';
+}
+
 function LangPicker() {
   const wrap = el('div', { className: 'lang-wrap' });
   const sel  = el('select', { className: 'lang-select' });
@@ -132,23 +239,106 @@ function LangPicker() {
     if (l.code === getLang()) opt.selected = true;
     sel.append(opt);
   }
-  sel.addEventListener('change', () => { setLang(sel.value); });
+  sel.addEventListener('change', () => {
+    setLang(sel.value);
+    if (state.query) {
+      doSearch(state.query, state.category);
+    } else {
+      renderApp();
+    }
+  });
   const arrow = el('span', { className: 'lang-arrow', html: svg('<polyline points="6 9 12 15 18 9"/>', 12) });
   wrap.append(sel, arrow);
   return wrap;
 }
 
+function EnginePicker() {
+  const details = el('details', { className: 'engine-picker' });
+  const selectedCount = state.selectedEngines.length;
+  const summary = el('summary', { className: 'engine-picker-summary' },
+    el('span', { className: 'engine-picker-title' }, selectedCount ? `Engines (${selectedCount})` : 'Engines (all)'),
+    iconEl('chevron', 'engine-chevron'),
+  );
+
+  const body = el('div', { className: 'engine-picker-body' });
+  const presetRow = el('div', { className: 'engine-preset-row' });
+  ENGINE_PRESETS.forEach((preset) => {
+    presetRow.append(el('button', {
+      className: `btn ${preset.id === 'balanced' ? 'btn-primary' : ''}`,
+      type: 'button',
+      onClick: () => {
+        setSelectedEngines(preset.engines);
+        details.open = false;
+        if (state.query) doSearch(state.query, state.category);
+        else renderApp();
+      },
+    }, preset.label));
+  });
+  body.append(presetRow);
+
+  ENGINE_GROUPS.forEach((group) => {
+    const card = el('div', { className: 'engine-group' });
+    card.append(el('div', { className: 'engine-group-title' }, group.label));
+    const list = el('div', { className: 'engine-chip-wrap' });
+    group.items.forEach((engine) => {
+      const checked = state.selectedEngines.includes(engine);
+      const id = `engine-${engine.replace(/[^a-z0-9]+/g, '-')}-${Math.random().toString(36).slice(2, 6)}`;
+      const input = el('input', { id, type: 'checkbox', ...(checked ? { checked: '' } : {}) });
+      const label = el('label', { className: 'engine-chip', for: id }, input, el('span', {}, engine));
+      list.append(label);
+    });
+    card.append(list);
+    body.append(card);
+  });
+
+  body.append(el('div', { className: 'engine-actions' },
+    el('button', {
+      className: 'btn btn-primary',
+      type: 'button',
+      onClick: () => {
+        const selected = [...details.querySelectorAll('.engine-chip input:checked')]
+          .map((node) => node.parentElement?.textContent?.trim().toLowerCase())
+          .filter(Boolean);
+        setSelectedEngines(selected);
+        details.open = false;
+        if (state.query) doSearch(state.query, state.category);
+        else renderApp();
+      },
+    }, 'Apply'),
+    el('button', {
+      className: 'btn',
+      type: 'button',
+      onClick: () => {
+        setSelectedEngines([]);
+        details.open = false;
+        if (state.query) doSearch(state.query, state.category);
+        else renderApp();
+      },
+    }, 'Reset'),
+  ));
+
+  details.append(summary, body);
+  return details;
+}
+
 // ─── Search form ──────────────────────────────────────────────────────────
 function SearchForm(value, onSearch) {
   const form  = el('form', { className: 'search-form' });
   const sicon = el('span', { className: 'search-icon', html: ICONS.search });
+  const listId = `search-history-list-${Math.random().toString(36).slice(2, 8)}`;
   const input = el('input', {
     className: 'search-input', type: 'search',
     placeholder: 'Search...', value: value || '',
     autocomplete: 'off', autocorrect: 'off', autocapitalize: 'off', spellcheck: 'false',
+    ...(state.historyEnabled ? { list: listId } : {}),
   });
   const btn = el('button', { className: 'search-btn', type: 'submit', html: ICONS.search });
   form.append(sicon, input, btn);
+  if (state.historyEnabled && state.searchHistory.length) {
+    const dl = el('datalist', { id: listId });
+    state.searchHistory.slice(0, 12).forEach((q) => dl.append(el('option', { value: q })));
+    form.append(dl);
+  }
   form.addEventListener('submit', (e) => {
     e.preventDefault();
     const q = input.value.trim();
@@ -472,8 +662,11 @@ function flattenSocialResults(payload) {
   ].filter((item) => item.url);
 }
 
-async function runSearchProgressive(q, lang, category) {
+async function runSearchProgressive(q, lang, category, engines = []) {
   const params = new URLSearchParams({ q, lang, cat: category });
+  if (Array.isArray(engines) && engines.length > 0) {
+    params.set('engines', engines.join(','));
+  }
   const response = await fetch(`/api/search-stream?${params.toString()}`);
   if (!response.ok) throw new Error(`HTTP ${response.status}`);
 
@@ -531,6 +724,7 @@ async function runSearchProgressive(q, lang, category) {
 
 async function doSearch(q, category = state.category) {
   if (!q.trim()) return;
+  addSearchToHistory(q);
   state.category = ['web', 'images', 'news'].includes(category) ? category : 'web';
   state.loading = true;
   state.results = [];
@@ -544,11 +738,14 @@ async function doSearch(q, category = state.category) {
   state.socialData = [];
   renderApp();
 
-  const lang = getLang();
+  const lang = getResolvedLang();
+  const engines = state.selectedEngines.slice();
 
   try {
-    const searchPromise = runSearchProgressive(q, lang, state.category).catch(async () => {
-      return api(`/api/search?q=${encodeURIComponent(q)}&lang=${lang}&cat=${encodeURIComponent(state.category)}`);
+    const searchPromise = runSearchProgressive(q, lang, state.category, engines).catch(async () => {
+      const p = new URLSearchParams({ q, lang, cat: state.category });
+      if (engines.length > 0) p.set('engines', engines.join(','));
+      return api(`/api/search?${p.toString()}`);
     });
     const promises = [
       searchPromise,
@@ -677,6 +874,7 @@ function renderApp() {
       type: 'button',
     }, cat.label));
   });
+  categoryBar.append(EnginePicker());
 
   const main = el('div', { className: 'main' });
 
@@ -696,6 +894,7 @@ function renderApp() {
       const meta = el('div', { className: 'results-meta' });
       meta.append(document.createTextNode(`${state.results.length} results`));
       if (state.providers.length) meta.append(document.createTextNode(' · ' + state.providers.join(', ')));
+      if (state.selectedEngines.length) meta.append(document.createTextNode(' · engines: ' + state.selectedEngines.join(', ')));
       main.append(meta);
     }
 
@@ -728,7 +927,10 @@ function renderApp() {
 function renderHome(app) {
   const home = el('div', { className: 'home' },
     el('div', { className: 'home-logo' }, 'Term', el('strong', {}, 'Search')),
-    el('div', { className: 'home-tagline' }, 'Personal search engine · privacy-first · local-first'),
+    el('div', { className: 'home-tagline' },
+      el('span', { className: 'tagline-desktop' }, 'Personal search engine · privacy-first · local-first'),
+      el('span', { className: 'tagline-mobile' }, 'Private local search'),
+    ),
     el('div', { className: 'home-search' }, SearchForm('', (q) => { state.query = q; state.category = 'web'; doSearch(q, 'web'); })),
     el('div', { className: 'home-actions' },
       LangPicker(),
@@ -767,6 +969,7 @@ async function renderSettings() {
   const brave  = cfg.brave  || {};
   const mojeek = cfg.mojeek || {};
   const searxng = cfg.searxng || {};
+  const detectedPreset = detectPresetFromBase(ai.api_base);
 
   const header = el('div', { className: 'header' },
     el('button', { className: 'btn', onClick: () => history.back() }, iconEl('back'), ' Back'),
@@ -788,11 +991,152 @@ async function renderSettings() {
   }
 
   const saveAlertEl = el('div', { style: 'display:none' });
+  const aiModelStatus = el('div', { id: 'ai-model-status', style: 'display:none' });
+  const historyInfoEl = el('div', { id: 'history-preview', className: 'form-hint', style: 'margin-top:8px' });
+  const presetSelect = el('select', { className: 'form-input', id: 'ai-preset' });
+  presetSelect.append(el('option', { value: 'custom' }, 'Custom'));
+  AI_PRESETS.forEach((preset) => {
+    const opt = el('option', { value: preset.id }, preset.label);
+    if (preset.id === detectedPreset) opt.selected = true;
+    presetSelect.append(opt);
+  });
+  const modelInput = makeInput('ai-model', ai.model, 'qwen3.5:4b');
+  const modelSelect = el('select', { className: 'form-input', id: 'ai-model-select' },
+    el('option', { value: '' }, 'Load models first…')
+  );
+  const modelQuickList = el('div', { id: 'ai-model-quick-list', className: 'model-quick-list' },
+    el('div', { className: 'form-hint' }, 'No models loaded.')
+  );
+  let loadedModels = [];
+
+  function setModelStatus(message, type = 'info') {
+    aiModelStatus.style.display = 'block';
+    aiModelStatus.className = `alert alert-${type}`;
+    aiModelStatus.textContent = message;
+  }
+
+  function renderHistoryPreview() {
+    if (!state.historyEnabled) {
+      historyInfoEl.textContent = 'Search history disabled.';
+      return;
+    }
+    if (!state.searchHistory.length) {
+      historyInfoEl.textContent = 'No searches saved yet.';
+      return;
+    }
+    historyInfoEl.textContent = `Recent: ${state.searchHistory.slice(0, 8).join(' · ')}`;
+  }
+
+  function populateModelList(models) {
+    loadedModels = models.slice();
+    modelSelect.innerHTML = '';
+    for (const model of models) {
+      modelSelect.append(el('option', { value: model }, model));
+    }
+    modelQuickList.innerHTML = '';
+    models.forEach((model) => {
+      modelQuickList.append(el('button', {
+        className: 'model-chip-btn',
+        type: 'button',
+        onClick: () => {
+          const modelField = document.getElementById('ai-model');
+          if (modelField) modelField.value = model;
+          modelSelect.value = model;
+          [...modelQuickList.querySelectorAll('.model-chip-btn')].forEach((n) => n.classList.remove('active'));
+          const active = [...modelQuickList.querySelectorAll('.model-chip-btn')].find((n) => n.textContent === model);
+          if (active) active.classList.add('active');
+        },
+      }, model));
+    });
+    const current = val('ai-model');
+    if (current && models.includes(current)) {
+      modelSelect.value = current;
+      const active = [...modelQuickList.querySelectorAll('.model-chip-btn')].find((n) => n.textContent === current);
+      if (active) active.classList.add('active');
+    }
+  }
+
+  async function loadModels(trigger = 'manual') {
+    const base = val('ai-base');
+    const key = val('ai-key');
+    const presetId = val('ai-preset');
+    if (!base) {
+      setModelStatus('Set API endpoint first.', 'info');
+      return;
+    }
+    const preset = AI_PRESETS.find((p) => p.id === presetId);
+    if (preset?.keyRequired && !key) {
+      setModelStatus(`Insert API key for ${preset.label} to load models.`, 'info');
+      return;
+    }
+
+    const btn = document.getElementById('ai-load-models-btn');
+    if (btn) btn.disabled = true;
+    setModelStatus('Loading models…', 'info');
+    try {
+      const res = await api('/api/config/models', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ api_base: base, api_key: key, preset: presetId }),
+      });
+      const models = Array.isArray(res.models) ? res.models : [];
+      if (!models.length) {
+        setModelStatus(`No models found${res.provider ? ` for ${res.provider}` : ''}.`, 'err');
+        modelSelect.innerHTML = '';
+        modelSelect.append(el('option', { value: '' }, 'No models found'));
+        modelQuickList.innerHTML = '';
+        modelQuickList.append(el('div', { className: 'form-hint' }, 'No models loaded.'));
+        loadedModels = [];
+        return;
+      }
+      populateModelList(models);
+      const current = val('ai-model');
+      if (!current || !models.includes(current)) {
+        const modelField = document.getElementById('ai-model');
+        if (modelField) modelField.value = models[0];
+        modelSelect.value = models[0];
+      }
+      setModelStatus(`Loaded ${models.length} model(s)${res.provider ? ` from ${res.provider}` : ''}.`, 'ok');
+    } catch (e) {
+      setModelStatus(`Model load failed: ${e.message}`, 'err');
+    } finally {
+      if (btn) btn.disabled = false;
+      if (trigger === 'manual') {
+        setTimeout(() => { aiModelStatus.style.display = 'none'; }, 4500);
+      }
+    }
+  }
+
+  function applyPreset() {
+    const presetId = val('ai-preset');
+    const preset = AI_PRESETS.find((p) => p.id === presetId);
+    const hintEl = document.getElementById('ai-preset-hint');
+    if (!preset) {
+      if (hintEl) hintEl.textContent = 'Custom endpoint mode.';
+      return;
+    }
+    const baseField = document.getElementById('ai-base');
+    const modelField = document.getElementById('ai-model');
+    if (baseField) baseField.value = preset.api_base;
+    if (modelField && (!modelField.value || modelField.value === ai.model) && preset.defaultModel) {
+      modelField.value = preset.defaultModel;
+    }
+    if (hintEl) {
+      hintEl.textContent = preset.keyRequired
+        ? `Preset ready: insert API key for ${preset.label}, then load models.`
+        : `Preset ready: local endpoint (${preset.label}).`;
+    }
+    if (!preset.keyRequired || val('ai-key')) {
+      loadModels('preset');
+    }
+  }
 
   async function saveSettings() {
     const aiKey = val('ai-key');
     const braveKey = val('brave-key');
     const mojeekKey = val('mojeek-key');
+    setHistoryEnabled(isChecked('history-enabled'));
+    renderHistoryPreview();
     const update = {
       ai: {
         api_base: val('ai-base'),
@@ -920,15 +1264,23 @@ async function renderSettings() {
     el('div', { className: 'settings-section' },
       el('h2', {}, 'AI Configuration (optional)'),
       el('div', { className: 'alert alert-info', style: 'margin-bottom:12px;font-size:11px' },
-        'Any OpenAI-compatible endpoint: Ollama, LM Studio, Groq, OpenAI, Z.AI, Chutes.ai…'
+        'Preset ready: just set key (if required), load models, save.'
+      ),
+      el('div', { className: 'form-group' },
+        el('label', { className: 'form-label', for: 'ai-preset' }, 'Preset'),
+        presetSelect,
+        el('div', { className: 'form-row', style: 'margin-top:6px' },
+          el('button', { id: 'ai-preset-apply-btn', className: 'btn', onClick: applyPreset, type: 'button' }, 'Apply preset'),
+          el('span', { id: 'ai-preset-hint', className: 'form-hint', style: 'margin-top:0' }, 'Select a preset to prefill endpoint/model.'),
+        ),
       ),
       el('div', { className: 'form-group' },
         el('label', { className: 'form-label', for: 'ai-base' }, 'API Endpoint'),
         makeInput('ai-base', ai.api_base, 'http://localhost:11434/v1'),
         el('div', { className: 'form-hint' },
-          'Localhost: localhost:11434/v1 (Ollama) · localhost:1234/v1 (LM Studio)',
+          'Included presets: Chutes.ai · Anthropic · OpenAI · OpenRoute/OpenRouter · llama.cpp · Ollama · LM Studio',
           el('br', {}),
-          'Chutes/OpenAI-compatible: llm.chutes.ai/v1 · OpenAI: api.openai.com/v1',
+          'You can also keep custom OpenAI-compatible endpoints.',
         ),
       ),
       el('div', { className: 'form-group' },
@@ -938,11 +1290,15 @@ async function renderSettings() {
       ),
       el('div', { className: 'form-group' },
         el('label', { className: 'form-label', for: 'ai-model' }, 'Model'),
-        makeInput('ai-model', ai.model, 'qwen3.5:4b'),
-        el('div', { className: 'form-hint' },
-          'Localhost: qwen3.5:4b, llama3.2, mistral… · Chutes: deepseek-ai/DeepSeek-V3.2-TEE',
-          el('br', {}), 'OpenAI: gpt-4o-mini',
+        modelInput,
+        el('div', { className: 'form-hint', style: 'margin-top:4px' }, 'Model list (tap to open):'),
+        modelSelect,
+        modelQuickList,
+        el('div', { className: 'form-row', style: 'margin-top:6px' },
+          el('button', { id: 'ai-load-models-btn', className: 'btn', onClick: () => loadModels('manual'), type: 'button' }, 'Load models'),
+          el('span', { className: 'form-hint', style: 'margin-top:0' }, 'Auto-loads from endpoint with current key.'),
         ),
+        aiModelStatus,
       ),
       el('div', { className: 'form-row', style: 'margin-top:4px' },
         el('button', { id: 'ai-test-btn', className: 'btn btn-primary', onClick: testAi }, 'Test Connection'),
@@ -951,6 +1307,31 @@ async function renderSettings() {
       el('div', { id: 'ai-test-result', style: 'display:none' }),
     ),
 
+    // Search history
+    el('div', { className: 'settings-section' },
+      el('h2', {}, 'Search History'),
+      el('div', { className: 'toggle-row' },
+        el('span', { className: 'toggle-label' }, 'Save search history'),
+        el('label', { className: 'toggle' },
+          el('input', { type: 'checkbox', id: 'history-enabled', ...(state.historyEnabled ? { checked: '' } : {}) }),
+          el('span', { className: 'toggle-slider' }),
+        ),
+      ),
+      historyInfoEl,
+      el('div', { style: 'margin-top:10px;display:flex;gap:8px;align-items:center' },
+        el('button', {
+          className: 'btn',
+          type: 'button',
+          onClick: () => {
+            state.searchHistory = [];
+            localStorage.removeItem('ts-history');
+            renderHistoryPreview();
+          },
+        }, 'Clear history'),
+        el('button', { className: 'btn btn-primary', onClick: saveSettings, type: 'button' }, 'Save preference'),
+      ),
+    ),
+
     // Providers
     el('div', { className: 'settings-section' },
       el('h2', {}, 'Search Providers'),
@@ -1014,7 +1395,7 @@ async function renderSettings() {
     // Server info
     el('div', { className: 'settings-section' },
       el('h2', {}, 'Server Info'),
-      el('div', { className: 'info-row' }, el('span', { className: 'info-key' }, 'Version'),          el('span', { className: 'info-val' }, health?.version || '0.3.0')),
+      el('div', { className: 'info-row' }, el('span', { className: 'info-key' }, 'Version'),          el('span', { className: 'info-val' }, health?.version || '0.3.2')),
       el('div', { className: 'info-row' }, el('span', { className: 'info-key' }, 'Active providers'), el('span', { className: 'info-val' }, (health?.providers || []).join(', ') || 'none')),
       el('div', { className: 'info-row' }, el('span', { className: 'info-key' }, 'AI'),               el('span', { className: 'info-val' }, health?.ai_enabled ? `enabled (${health.ai_model})` : 'not configured')),
       el('div', { className: 'info-row' }, el('span', { className: 'info-key' }, 'GitHub'),           el('a', { href: 'https://github.com/DioNanos/termsearch', target: '_blank', className: 'info-val', style: 'color:var(--link)' }, 'DioNanos/termsearch')),
@@ -1041,6 +1422,47 @@ async function renderSettings() {
   );
 
   app.append(header, main);
+  renderHistoryPreview();
+  document.getElementById('history-enabled')?.addEventListener('change', (e) => {
+    setHistoryEnabled(Boolean(e.target?.checked));
+    renderHistoryPreview();
+  });
+  modelSelect.addEventListener('change', () => {
+    if (!modelSelect.value) return;
+    const modelField = document.getElementById('ai-model');
+    if (modelField) modelField.value = modelSelect.value;
+    [...modelQuickList.querySelectorAll('.model-chip-btn')].forEach((n) => {
+      n.classList.toggle('active', n.textContent === modelSelect.value);
+    });
+  });
+  modelSelect.addEventListener('focus', () => {
+    if (!loadedModels.length) loadModels('auto');
+  });
+  modelInput.addEventListener('input', () => {
+    const current = modelInput.value || '';
+    if ([...modelSelect.options].some((opt) => opt.value === current)) {
+      modelSelect.value = modelInput.value;
+    }
+    [...modelQuickList.querySelectorAll('.model-chip-btn')].forEach((n) => {
+      n.classList.toggle('active', n.textContent === current);
+      n.style.display = !current || n.textContent.toLowerCase().includes(current.toLowerCase()) ? 'inline-flex' : 'none';
+    });
+  });
+  document.getElementById('ai-key')?.addEventListener('change', () => loadModels('auto'));
+  document.getElementById('ai-base')?.addEventListener('change', () => loadModels('auto'));
+  presetSelect.addEventListener('change', applyPreset);
+  if (detectedPreset && detectedPreset !== 'custom') {
+    const hintEl = document.getElementById('ai-preset-hint');
+    const preset = AI_PRESETS.find((p) => p.id === detectedPreset);
+    if (hintEl && preset) {
+      hintEl.textContent = preset.keyRequired
+        ? `Preset detected: ${preset.label}. Insert key and load models.`
+        : `Preset detected: ${preset.label}.`;
+    }
+  }
+  if (ai.api_base && (!AI_PRESETS.find((p) => p.id === detectedPreset)?.keyRequired)) {
+    loadModels('auto');
+  }
 }
 
 // ─── Bootstrap ────────────────────────────────────────────────────────────