leetcode-capture-helper 0.0.0-stage → 0.1.1

package/runtime/extension/shared/local-server.js

@@ -0,0 +1,149 @@
+// extension/shared/local-server.js - best-effort facts about the local model server
+// LocalBackend talks to: whether it is Ollama (so its native chat API, the
+// only one that honors a requested context window, can be used), and how big
+// the model's context window really is. Works with any OpenAI-compatible
+// server: every probe is optional, has a short timeout, and is ignored on any
+// error or unexpected shape, so an unknown server simply keeps the
+// configured window (plus LocalBackend's silent-truncation guard). Uses only
+// fetch and AbortController, no Node API, so it can also run inside the
+// browser extension.
+//
+// Probes, all read-only:
+// - Ollama: GET /api/version (identifies it), POST /api/show (the model's
+//   trained context_length) and GET /api/ps (the window a loaded model is
+//   running with, which the OpenAI-compatible endpoint is stuck with).
+// - LM Studio: GET /api/v0/models (loaded_context_length, else
+//   max_context_length).
+// - llama.cpp server: GET /props (default_generation_settings.n_ctx).
+// - vLLM: GET <base>/models (max_model_len).
+
+export const PROBE_TIMEOUT_MS = 1500;
+
+// The server root, for the routes that do not live under the
+// OpenAI-compatible /v1 prefix: a trailing /v1 (and slashes) is dropped.
+export function serverRoot(baseUrl) {
+  return String(baseUrl || '')
+    .replace(/\/+$/, '')
+    .replace(/\/v1$/, '');
+}
+
+function positiveInt(value) {
+  const n = Number(value);
+  return Number.isInteger(n) && n > 0 ? n : null;
+}
+
+// Ollama names a model "name:tag" and fills in ":latest" when none is given.
+function sameOllamaModel(name, model) {
+  if (typeof name !== 'string' || !model) return false;
+  const withTag = (s) => (s.includes(':') ? s : `${s}:latest`);
+  return withTag(name) === withTag(model);
+}
+
+// GET /api/version answers {"version": "0.x.y"} on Ollama and nothing like
+// it anywhere else.
+export function looksLikeOllamaVersion(json) {
+  return Boolean(json && typeof json === 'object' && typeof json.version === 'string' && json.version);
+}
+
+// POST /api/show: model_info carries "<architecture>.context_length".
+export function parseOllamaShow(json) {
+  const info = json && typeof json === 'object' ? json.model_info : null;
+  if (!info || typeof info !== 'object') return null;
+  for (const [key, value] of Object.entries(info)) {
+    if (key.endsWith('.context_length')) {
+      const n = positiveInt(value);
+      if (n) return n;
+    }
+  }
+  return null;
+}
+
+// GET /api/ps: the loaded models, each with the context_length it runs with.
+export function parseOllamaPs(json, model) {
+  const models = json && Array.isArray(json.models) ? json.models : [];
+  const entry = models.find((m) => m && (sameOllamaModel(m.name, model) || sameOllamaModel(m.model, model)));
+  return entry ? positiveInt(entry.context_length) : null;
+}
+
+// GET /api/v0/models (LM Studio): the loaded window wins over the maximum.
+export function parseLmStudioModels(json, model) {
+  const models = json && Array.isArray(json.data) ? json.data : [];
+  const entry = models.find((m) => m && m.id === model);
+  if (!entry) return null;
+  return positiveInt(entry.loaded_context_length) || positiveInt(entry.max_context_length);
+}
+
+// GET /props (llama.cpp server): the per-slot window.
+export function parseLlamaCppProps(json) {
+  if (!json || typeof json !== 'object') return null;
+  return positiveInt(json.default_generation_settings?.n_ctx) || positiveInt(json.n_ctx);
+}
+
+// GET /v1/models (vLLM): max_model_len on the served model.
+export function parseOpenAIModels(json, model) {
+  const models = json && Array.isArray(json.data) ? json.data : [];
+  const entry = models.find((m) => m && m.id === model);
+  return entry ? positiveInt(entry.max_model_len) : null;
+}
+
+// One probe: the parsed JSON body of a 2xx answer, or null on anything else
+// (refused, timed out, not JSON, an error status).
+export async function probeJson(url, { method = 'GET', body, headers = {}, timeoutMs = PROBE_TIMEOUT_MS, fetchImpl = fetch } = {}) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetchImpl(url, {
+      method,
+      headers: { ...(body === undefined ? {} : { 'Content-Type': 'application/json' }), ...headers },
+      body: body === undefined ? undefined : JSON.stringify(body),
+      signal: controller.signal,
+    });
+    if (!response.ok) {
+      response.body?.cancel?.().catch(() => {});
+      return null;
+    }
+    const text = await response.text();
+    return JSON.parse(text);
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// Runs every probe at once and reports what it learned:
+// `{ ollama, window }`, where `window` is `{ tokens, source }` (the smallest
+// window any probe reported) or null. `apiStyle` is the style that will be
+// used ('native' or 'openai'); a loaded Ollama model's running window only
+// matters for 'openai', since native requests ask for their own.
+export async function probeServer({ baseUrl, model, apiKey = null, apiStyle = null, timeoutMs = PROBE_TIMEOUT_MS, fetchImpl = fetch }) {
+  const root = serverRoot(baseUrl);
+  const base = String(baseUrl || '').replace(/\/+$/, '');
+  const headers = apiKey ? { Authorization: `Bearer ${apiKey}` } : {};
+  const get = (url) => probeJson(url, { headers, timeoutMs, fetchImpl });
+  const [version, show, ps, lmStudio, props, models] = await Promise.all([
+    get(`${root}/api/version`),
+    probeJson(`${root}/api/show`, { method: 'POST', body: { model }, headers, timeoutMs, fetchImpl }),
+    get(`${root}/api/ps`),
+    get(`${root}/api/v0/models`),
+    get(`${root}/props`),
+    get(`${base}/models`),
+  ]);
+  const ollama = looksLikeOllamaVersion(version);
+  const style = apiStyle || (ollama ? 'native' : 'openai');
+  const found = [];
+  if (ollama) {
+    const trained = parseOllamaShow(show);
+    if (trained) found.push({ tokens: trained, source: 'Ollama /api/show' });
+    const running = style === 'openai' ? parseOllamaPs(ps, model) : null;
+    if (running) found.push({ tokens: running, source: 'Ollama /api/ps' });
+  }
+  const lm = parseLmStudioModels(lmStudio, model);
+  if (lm) found.push({ tokens: lm, source: 'LM Studio /api/v0/models' });
+  const llama = parseLlamaCppProps(props);
+  if (llama) found.push({ tokens: llama, source: 'llama.cpp /props' });
+  const vllm = parseOpenAIModels(models, model);
+  if (vllm) found.push({ tokens: vllm, source: '/v1/models max_model_len' });
+  const window = found.reduce((min, w) => (!min || w.tokens < min.tokens ? w : min), null);
+  return { ollama, apiStyle: style, window };
+}

package/runtime/extension/shared/package.json

@@ -0,0 +1,4 @@
+{
+  "private": true,
+  "type": "module"
+}

package/runtime/extension/shared/practice.js

@@ -0,0 +1,228 @@
+// extension/shared/practice.js - "Practice a skill": problems from all of
+// LeetCode (shared/problem-index.js, bundled public metadata) for one skill,
+// ranked by popularity near a reference difficulty. Pure: no storage, no
+// network, no Node or browser APIs (extension/shared.test.js checks that).
+//
+// Skills are a fixed friendly list mapped onto LeetCode's own topic tags,
+// never the tags of the problem the student is on, so a suggestion never
+// hints at how that problem is solved.
+//
+// Mapping decisions (SKILLS below):
+//   - A skill matches a problem when any one of its `tags` entries matches.
+//     An entry is a tag slug, or an array of slugs that must all be present
+//     (Graphs counts a grid search, BFS or DFS together with Matrix, since
+//     LeetCode tags Number of Islands and Rotting Oranges that way and never
+//     "graph").
+//   - Graphs ("Graph Theory" on LeetCode, slug `graph`) also takes Union
+//     Find and the specialised graph tags (topological sort, shortest path,
+//     Dijkstra, DAGs, bipartite graphs, minimum spanning trees, strongly
+//     connected components, Eulerian circuits, biconnected components).
+//   - Trees take Tree, Binary Tree and Binary Search Tree; Linked lists take
+//     Doubly-Linked List; Dynamic programming takes Memoization; Bit
+//     manipulation takes Bitmask; Math takes Number Theory, Combinatorics
+//     and Geometry; Strings take String Matching; Dynamic programming also
+//     takes Knapsack and DP on Trees; Heaps take the lone Heap tag.
+//   - LeetCode has no intervals tag, so Intervals is Sweep Line, a problem
+//     of a bundled list's Intervals topic (`listTopic`), or a title naming an
+//     interval together with Sorting, Greedy, a heap or an ordered set
+//     (`titles`; a title alone also caught "Count Odd Numbers in an Interval
+//     Range" and a JavaScript exercise).
+//   - Left out on purpose: Sorting, Simulation, Counting, Enumeration and
+//     similar tags (an aid in most problems, not a skill to practice on its
+//     own), Database (SQL, which the SQL 50 list covers), Concurrency and
+//     Shell.
+//
+// Ranking (practiceSuggestions):
+//   - Candidates: the skill matches, not paid-only, not solved, not the
+//     excluded problem (the one the student is on).
+//   - Tiers by difficulty: the reference level first, then one level up,
+//     then one level down (Easy: Easy, Medium; Medium: Medium, Hard, Easy;
+//     Hard: Hard, Medium). No reference (a problem the index does not have):
+//     one tier of every level.
+//   - Within a tier, by score: LeetCode likes, times CURATED_BOOST when the
+//     problem is on one of the bundled lists (shared/roadmap.js LISTS); then
+//     total submissions, then frontend id, then slug, so the order is stable.
+
+import { PROBLEM_INDEX } from './problem-index.js';
+import { LISTS } from './roadmap.js';
+
+export const LEVELS = ['Easy', 'Medium', 'Hard'];
+export const PAGE_SIZE = 3;
+export const CURATED_BOOST = 1.25;
+const PAID = 1;
+
+const GRAPH_TAGS = ['graph', 'union-find', 'topological-sort', 'shortest-path', 'dijkstra', 'directed-acyclic-graph', 'bipartite-graph', 'minimum-spanning-tree', 'strongly-connected-component', 'eulerian-circuit', 'biconnected-component'];
+
+// In the order the chips show: the basics first, then structures, then
+// techniques.
+export const SKILLS = [
+  { id: 'arrays', label: 'Arrays', tags: ['array'] },
+  { id: 'hash-maps', label: 'Hash maps', tags: ['hash-table'] },
+  { id: 'strings', label: 'Strings', tags: ['string', 'string-matching'] },
+  { id: 'two-pointers', label: 'Two pointers', tags: ['two-pointers'] },
+  { id: 'sliding-window', label: 'Sliding window', tags: ['sliding-window'] },
+  { id: 'stacks', label: 'Stacks', tags: ['stack'] },
+  { id: 'monotonic-stack', label: 'Monotonic stack', tags: ['monotonic-stack'] },
+  { id: 'binary-search', label: 'Binary search', tags: ['binary-search'] },
+  { id: 'linked-lists', label: 'Linked lists', tags: ['linked-list', 'doubly-linked-list'] },
+  { id: 'trees', label: 'Trees', tags: ['tree', 'binary-tree', 'binary-search-tree'] },
+  { id: 'tries', label: 'Tries', tags: ['trie'] },
+  { id: 'heaps', label: 'Heaps', tags: ['heap-priority-queue', 'heap'] },
+  { id: 'graphs', label: 'Graphs', tags: [...GRAPH_TAGS, ['breadth-first-search', 'matrix'], ['depth-first-search', 'matrix']] },
+  { id: 'backtracking', label: 'Backtracking', tags: ['backtracking'] },
+  { id: 'dynamic-programming', label: 'Dynamic programming', tags: ['dynamic-programming', 'memoization', 'knapsack-problem', 'dp-on-trees'] },
+  { id: 'greedy', label: 'Greedy', tags: ['greedy'] },
+  { id: 'intervals', label: 'Intervals', tags: ['sweep-line'], listTopic: /^intervals?$/i, titles: { pattern: /\bintervals?\b/i, withAny: ['sorting', 'greedy', 'heap-priority-queue', 'ordered-set'] } },
+  { id: 'bit-manipulation', label: 'Bit manipulation', tags: ['bit-manipulation', 'bitmask'] },
+  { id: 'math', label: 'Math', tags: ['math', 'number-theory', 'combinatorics', 'geometry'] },
+  { id: 'design', label: 'Design', tags: ['design'] },
+];
+
+const SKILL_BY_ID = new Map(SKILLS.map((s) => [s.id, s]));
+
+export function skillById(id) {
+  return (typeof id === 'string' && SKILL_BY_ID.get(id)) || null;
+}
+
+// What the panel shows of the list: ids and labels only.
+export function skillChoices() {
+  return SKILLS.map((s) => ({ id: s.id, label: s.label }));
+}
+
+// The index decoded once: { bySlug, problems: [{ id, slug, title, level,
+// paid, likes, submissions, tags: Set<slug>, curated: list title or null }] }.
+const cache = new WeakMap();
+function decode(index) {
+  let decoded = cache.get(index);
+  if (decoded) return decoded;
+  const onList = new Map();
+  const topics = new Map(); // slug -> titles of the list topics that have it
+  for (const list of LISTS) for (const topic of list.topics) for (const p of topic.problems) {
+    if (!onList.has(p.slug)) onList.set(p.slug, list.title);
+    topics.set(p.slug, [...(topics.get(p.slug) || []), topic.title]);
+  }
+  const problems = index.problems.map(([id, slug, title, level, flags, likes, submissions, tags]) => ({
+    id,
+    slug,
+    title,
+    level,
+    paid: (flags & PAID) === PAID,
+    likes,
+    submissions,
+    tags: new Set(tags.map((t) => index.tags[t][0])),
+    curated: onList.get(slug) || null,
+    topics: topics.get(slug) || [],
+  }));
+  decoded = { problems, bySlug: new Map(problems.map((p) => [p.slug, p])), ranked: new Map() };
+  cache.set(index, decoded);
+  return decoded;
+}
+
+export function problemBySlug(slug, index = PROBLEM_INDEX) {
+  const p = typeof slug === 'string' ? decode(index).bySlug.get(slug) : null;
+  return p ? { slug: p.slug, title: p.title, difficulty: LEVELS[p.level], paid: p.paid } : null;
+}
+
+// The difficulty of a problem the index has, or null.
+export function referenceLevel(slug, index = PROBLEM_INDEX) {
+  const p = problemBySlug(slug, index);
+  return p ? p.difficulty : null;
+}
+
+export function matchesSkill(skill, problem) {
+  for (const entry of skill.tags) {
+    if (Array.isArray(entry) ? entry.every((t) => problem.tags.has(t)) : problem.tags.has(entry)) return true;
+  }
+  if (skill.listTopic && (problem.topics || []).some((t) => skill.listTopic.test(t))) return true;
+  return Boolean(skill.titles && skill.titles.pattern.test(problem.title) && skill.titles.withAny.some((t) => problem.tags.has(t)));
+}
+
+// The levels in the order they are offered for a reference level; null
+// means one tier of all levels.
+export function levelTiers(reference) {
+  const level = LEVELS.indexOf(reference);
+  if (level < 0) return [[0, 1, 2]];
+  return [level, level + 1, level - 1].filter((l) => l >= 0 && l < LEVELS.length).map((l) => [l]);
+}
+
+function score(p) {
+  return p.likes * (p.curated ? CURATED_BOOST : 1);
+}
+
+function compare(a, b) {
+  return score(b) - score(a) || b.submissions - a.submissions || compareIds(a.id, b.id) || (a.slug < b.slug ? -1 : a.slug > b.slug ? 1 : 0);
+}
+
+function compareIds(a, b) {
+  if (typeof a === 'number' && typeof b === 'number') return a - b;
+  return String(a).localeCompare(String(b), 'en', { numeric: true });
+}
+
+// Every free problem of the skill in offer order for a reference level,
+// solved or not (filtered per call), cached per skill and level.
+function rankedFor(skill, reference, index) {
+  const decoded = decode(index);
+  const key = `${skill.id}|${reference || ''}`;
+  let ranked = decoded.ranked.get(key);
+  if (ranked) return ranked;
+  const matching = decoded.problems.filter((p) => !p.paid && matchesSkill(skill, p));
+  ranked = [];
+  for (const tier of levelTiers(reference)) ranked.push(...matching.filter((p) => tier.includes(p.level)).sort(compare));
+  decoded.ranked.set(key, ranked);
+  return ranked;
+}
+
+export function formatCount(n) {
+  if (n < 1000) return String(n);
+  if (n < 10000) return `${(Math.floor(n / 100) / 10).toFixed(1).replace(/\.0$/, '')}k`;
+  if (n < 1e6) return `${Math.floor(n / 1000)}k`;
+  return `${(Math.floor(n / 1e5) / 10).toFixed(1).replace(/\.0$/, '')}M`;
+}
+
+const RELATION = { 0: 'Same level', 1: 'One level up', '-1': 'One level down' };
+
+// The one short line under a suggestion: how its level compares, how liked
+// it is, and the first bundled list that has it. Nothing about how to solve
+// it, or the problem the student is on.
+export function reasonFor(problem, reference) {
+  const parts = [];
+  const ref = LEVELS.indexOf(reference);
+  if (ref >= 0) parts.push(RELATION[problem.level - ref]);
+  parts.push(`${formatCount(problem.likes)} ${problem.likes === 1 ? 'like' : 'likes'}`);
+  if (problem.curated) parts.push(`on ${problem.curated}`);
+  return parts.join(' · ');
+}
+
+function solvedSet(solved) {
+  if (solved instanceof Set) return solved;
+  if (Array.isArray(solved)) return new Set(solved);
+  if (solved && typeof solved === 'object') return new Set(Object.keys(solved));
+  return new Set();
+}
+
+// The suggestions for one skill:
+//   { skill: { id, label } | null, reference, suggestions: [{ slug, title,
+//     difficulty, reason }], offset, total, more }
+// `reference` is 'Easy', 'Medium', 'Hard' or null; `solved` a Set, an array
+// of slugs or the solved store's record; `exclude` a slug never offered
+// (the problem the student is on); `offset` how many were shown already.
+// An unknown skill answers no suggestions.
+export function practiceSuggestions({ skill, reference = null, solved, exclude = null, offset = 0, count = PAGE_SIZE, index = PROBLEM_INDEX } = {}) {
+  const found = typeof skill === 'string' ? skillById(skill) : skill && SKILL_BY_ID.get(skill.id) === skill ? skill : null;
+  const level = LEVELS.includes(reference) ? reference : null;
+  const start = Number.isInteger(offset) && offset > 0 ? offset : 0;
+  const size = Number.isInteger(count) && count > 0 ? Math.min(count, 20) : PAGE_SIZE;
+  if (!found) return { skill: null, reference: level, suggestions: [], offset: 0, total: 0, more: false };
+  const done = solvedSet(solved);
+  const skip = new Set(Array.isArray(exclude) ? exclude : exclude ? [exclude] : []);
+  const open = rankedFor(found, level, index).filter((p) => !done.has(p.slug) && !skip.has(p.slug));
+  const page = open.slice(start, start + size);
+  return {
+    skill: { id: found.id, label: found.label },
+    reference: level,
+    suggestions: page.map((p) => ({ slug: p.slug, title: p.title, difficulty: LEVELS[p.level], reason: reasonFor(p, level) })),
+    offset: start,
+    total: open.length,
+    more: start + size < open.length,
+  };
+}