offcode 0.0.0-stage → 0.1.1

package/dist/cli.js

@@ -0,0 +1,793 @@
+#!/usr/bin/env node
+
+// src/cli.jsx
+import React2 from "react";
+import { render } from "ink";
+import fs7 from "node:fs";
+import path6 from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+
+// src/App.jsx
+import React, { useEffect, useMemo, useState } from "react";
+import fs5 from "node:fs";
+import { Box, Text, useApp, useInput, useStdout } from "ink";
+
+// src/data.js
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+var here = path.dirname(fileURLToPath(import.meta.url));
+var dataDir = path.resolve(here, "..", "data");
+var indexCache;
+function loadIndex() {
+  if (!indexCache) indexCache = JSON.parse(fs.readFileSync(path.join(dataDir, "index.json"), "utf8"));
+  return indexCache;
+}
+function loadProblem(slug) {
+  const f = path.join(dataDir, "problems", `${String(slug).replace(/[^a-z0-9-]/gi, "")}.json`);
+  return fs.existsSync(f) ? JSON.parse(fs.readFileSync(f, "utf8")) : null;
+}
+function filterProblems({ q = "", difficulty = "All", category = "" } = {}) {
+  const n = q.trim().toLowerCase();
+  return loadIndex().filter((p) => {
+    if (difficulty !== "All" && p.difficulty !== difficulty) return false;
+    if (category && p.category !== category) return false;
+    return !n || String(p.label) === n || p.title.toLowerCase().includes(n) || p.category.includes(n);
+  });
+}
+var allCategories = () => [...new Set(loadIndex().map((p) => p.category))].sort();
+function examplesMd(p) {
+  return (p.examples || []).map((e, i) => `**Example ${i + 1}**
+
+\`\`\`
+Input:  ${e.input}
+Output: ${e.output}${e.explanation ? `
+
+${e.explanation}` : ""}
+\`\`\``).join("\n\n");
+}
+var descriptionMd = (p) => `${p.statement.trim()}
+
+${examplesMd(p)}`;
+var hintsMd = (p) => p.hints.length ? p.hints.map((h, i) => `**Hint ${i + 1}.** ${h}`).join("\n\n") : "No hints.";
+var solutionMd = (p) => p.solution.trim() || "No solution.";
+function plain(md) {
+  return md.replace(/```[a-z]*\n?/g, "").replace(/\*\*(.*?)\*\*/g, "$1").replace(/`([^`]*)`/g, "$1").replace(/^#{1,6}\s*/gm, "").replace(/\n{3,}/g, "\n\n");
+}
+
+// src/scaffold.js
+import fs2 from "node:fs";
+import path2 from "node:path";
+var LANGS = {
+  go: { label: "Go", ext: "go" },
+  python: { label: "Python", ext: "py" },
+  cpp: { label: "C++", ext: "cpp" }
+};
+var LANG_KEYS = Object.keys(LANGS);
+var langFromExt = (f) => LANG_KEYS.find((k) => LANGS[k].ext === path2.extname(f).slice(1));
+function solutionPath(p, lang, base = process.cwd()) {
+  return path2.join(base, "offcode", `${p.label}-${p.slug}`, `solution.${LANGS[lang].ext}`);
+}
+function scaffold(slug, lang = "go", base = process.cwd()) {
+  if (!LANGS[lang]) throw new Error(`lang must be one of: ${LANG_KEYS.join(", ")}`);
+  const p = loadProblem(slug);
+  if (!p) throw new Error(`problem not found: ${slug}`);
+  const file2 = solutionPath(p, lang, base);
+  if (fs2.existsSync(file2)) return { file: file2, created: false };
+  fs2.mkdirSync(path2.dirname(file2), { recursive: true });
+  let code = p.starter[lang];
+  if (lang === "go") code = code.replace(/\{\s*\}\s*$/, '{\n	panic("not implemented")\n}');
+  if (lang === "python" && /:\s*$/.test(code)) code = code.trimEnd() + "\n        pass";
+  fs2.writeFileSync(file2, code + "\n");
+  return { file: file2, created: true };
+}
+
+// src/judge.js
+import fs3 from "node:fs";
+import os from "node:os";
+import path3 from "node:path";
+import { spawnSync } from "node:child_process";
+var JUDGE_LANGS = ["go", "python"];
+var TL_MS = 15e3;
+function resolveArg(raw) {
+  if (typeof raw === "string" && raw.startsWith("@javascript:")) {
+    const v = new Function(`return (${raw.slice(12)})`)();
+    return typeof v === "string" ? v : JSON.stringify(v);
+  }
+  return raw;
+}
+var norm = (v) => v === null ? null : v;
+function deepEq(a, b) {
+  if (Array.isArray(a) && Array.isArray(b)) return a.length === b.length && a.every((x, i) => deepEq(x, b[i]));
+  if (typeof a === "number" && typeof b === "number") return Math.abs(a - b) < 1e-5;
+  return a === b;
+}
+function canon(v) {
+  if (Array.isArray(v)) return JSON.stringify(v.map((x) => JSON.parse(canon(x))).sort((x, y) => JSON.stringify(x) < JSON.stringify(y) ? -1 : 1));
+  return JSON.stringify(v);
+}
+function same(got, exp, loose) {
+  if (got === null && Array.isArray(exp) && exp.length === 0) return true;
+  if (deepEq(norm(got), exp)) return true;
+  return loose && Array.isArray(got) && Array.isArray(exp) && canon(got) === canon(exp);
+}
+function parseGoSig(src) {
+  const m = src.match(/func\s+(\w+)\s*\(([^)]*)\)\s*([^{\n]*)\{/);
+  if (!m) throw new Error("Go: cannot find the solution function signature");
+  const raw = m[2].split(",").map((s) => s.trim()).filter(Boolean);
+  const params = [];
+  let pending = [];
+  for (const part of raw) {
+    const bits = part.split(/\s+/);
+    if (bits.length === 1) pending.push(bits[0]);
+    else {
+      for (const n of pending) params.push({ name: n, type: bits.slice(1).join(" ") });
+      pending = [];
+      params.push({ name: bits[0], type: bits.slice(1).join(" ") });
+    }
+  }
+  return { name: m[1], params, ret: m[3].trim() };
+}
+var GO_HELPERS = `
+type ListNode struct { Val int; Next *ListNode }
+type TreeNode struct { Val int; Left *TreeNode; Right *TreeNode }
+func mkList(raw string) *ListNode { var a []int; json.Unmarshal([]byte(raw), &a); var h *ListNode; for i := len(a)-1; i >= 0; i-- { h = &ListNode{a[i], h} }; return h }
+func mkLists(raw string) []*ListNode { var a [][]int; json.Unmarshal([]byte(raw), &a); r := make([]*ListNode, len(a)); for i, x := range a { for j := len(x)-1; j >= 0; j-- { r[i] = &ListNode{x[j], r[i]} } }; return r }
+func mkTree(raw string) *TreeNode {
+  var a []*int; json.Unmarshal([]byte(raw), &a)
+  if len(a) == 0 || a[0] == nil { return nil }
+  root := &TreeNode{Val: *a[0]}; q := []*TreeNode{root}; i := 1
+  for len(q) > 0 && i < len(a) {
+    n := q[0]; q = q[1:]
+    if i < len(a) && a[i] != nil { n.Left = &TreeNode{Val: *a[i]}; q = append(q, n.Left) }; i++
+    if i < len(a) && a[i] != nil { n.Right = &TreeNode{Val: *a[i]}; q = append(q, n.Right) }; i++
+  }
+  return root
+}
+func chars(raw string) [][]byte { var a [][]string; json.Unmarshal([]byte(raw), &a); r := make([][]byte, len(a)); for i, x := range a { r[i] = make([]byte, len(x)); for j, s := range x { if len(s) > 0 { r[i][j] = s[0] } } }; return r }
+func atoi(s string) int { n, _ := strconv.Atoi(strings.TrimSpace(s)); return n }
+func ser(v interface{}) string {
+  switch x := v.(type) {
+  case *ListNode:
+    a := []int{}; for n := x; n != nil; n = n.Next { a = append(a, n.Val) }; b, _ := json.Marshal(a); return string(b)
+  case *TreeNode:
+    if x == nil { return "[]" }
+    out := []string{}; q := []*TreeNode{x}
+    for len(q) > 0 { n := q[0]; q = q[1:]; if n == nil { out = append(out, "null"); continue }; out = append(out, strconv.Itoa(n.Val)); q = append(q, n.Left, n.Right) }
+    for len(out) > 0 && out[len(out)-1] == "null" { out = out[:len(out)-1] }
+    return "[" + strings.Join(out, ",") + "]"
+  }
+  b, err := json.Marshal(v); if err != nil { return "null" }; return string(b)
+}
+`;
+function goConv(t, i) {
+  const r = `raw[${i}]`;
+  if (t === "int") return `atoi(${r})`;
+  if (t === "string") return r;
+  if (t === "bool") return `${r} == "true"`;
+  if (t === "*ListNode") return `mkList(${r})`;
+  if (t === "[]*ListNode") return `mkLists(${r})`;
+  if (t === "*TreeNode") return `mkTree(${r})`;
+  if (t === "[][]byte") return `chars(${r})`;
+  return null;
+}
+function goHarness(sig) {
+  const decl = [];
+  const args2 = sig.params.map((p, i) => {
+    const c = goConv(p.type, i);
+    if (c) return c;
+    decl.push(`var a${i} ${p.type}; json.Unmarshal([]byte(raw[${i}]), &a${i})`);
+    return `a${i}`;
+  });
+  return `package main
+import ("bufio";"encoding/json";"fmt";"os";"strconv";"strings")
+${GO_HELPERS}
+func run(raw []string) (res string, err string) {
+  defer func() { if r := recover(); r != nil { err = fmt.Sprint(r) } }()
+  ${decl.join("\n  ")}
+  return ser(${sig.name}(${args2.map((a, i) => a.startsWith("a") && /^a\d+$/.test(a) ? a : a).join(", ")})), ""
+}
+func main() {
+  rd := bufio.NewReaderSize(os.Stdin, 1<<26)
+  var tests [][]string
+  if err := json.NewDecoder(rd).Decode(&tests); err != nil { fmt.Println("{\\"fatal\\":\\"bad input\\"}"); return }
+  w := bufio.NewWriter(os.Stdout)
+  for _, t := range tests {
+    r, e := run(t)
+    if e != "" { eb, _ := json.Marshal(e); fmt.Fprintf(w, "{\\"error\\":%s}\\n", eb) } else { fmt.Fprintf(w, "{\\"out\\":%s}\\n", r) }
+    w.Flush()
+  }
+}
+`;
+}
+var PY_PRE = `from typing import *
+import sys, json, collections, heapq, bisect, math, itertools, functools
+from collections import *
+class ListNode:
+    def __init__(self, val=0, next=None):
+        self.val = val
+        self.next = next
+class TreeNode:
+    def __init__(self, val=0, left=None, right=None):
+        self.val = val
+        self.left = left
+        self.right = right
+`;
+var PY_POST = (fn, types) => `
+def __mk_list(a):
+    h = None
+    for x in reversed(a): h = ListNode(x, h)
+    return h
+def __mk_tree(a):
+    if not a or a[0] is None: return None
+    root = TreeNode(a[0]); q = collections.deque([root]); i = 1
+    while q and i < len(a):
+        n = q.popleft()
+        if i < len(a) and a[i] is not None: n.left = TreeNode(a[i]); q.append(n.left)
+        i += 1
+        if i < len(a) and a[i] is not None: n.right = TreeNode(a[i]); q.append(n.right)
+        i += 1
+    return root
+def __ser(v):
+    if isinstance(v, ListNode):
+        r = []
+        while v: r.append(v.val); v = v.next
+        return r
+    if isinstance(v, TreeNode):
+        out = []; q = collections.deque([v])
+        while q:
+            n = q.popleft()
+            if n is None: out.append(None); continue
+            out.append(n.val); q.append(n.left); q.append(n.right)
+        while out and out[-1] is None: out.pop()
+        return out
+    if isinstance(v, (list, tuple, set)): return [__ser(x) for x in v]
+    return v
+__types = ${JSON.stringify(types)}
+def __conv(t, raw):
+    if t == 'int': return int(raw.strip())
+    if t == 'string': return raw
+    if t == 'boolean': return raw.strip() == 'true'
+    v = json.loads(raw)
+    if t == 'list_node': return __mk_list(v)
+    if t == 'list_node_array': return [__mk_list(x) for x in v]
+    if t == 'tree_node': return __mk_tree(v)
+    return v
+def __main():
+    tests = json.load(sys.stdin)
+    sol = Solution()
+    f = getattr(sol, ${JSON.stringify(fn)})
+    for raw in tests:
+        try:
+            r = __ser(f(*[__conv(t, x) for t, x in zip(__types, raw)]))
+            sys.stdout.write(json.dumps({"out": r}) + "\\n")
+        except BaseException as e:
+            sys.stdout.write(json.dumps({"error": type(e).__name__ + ": " + str(e)}) + "\\n")
+        sys.stdout.flush()
+__main()
+`;
+function pyMethod(src) {
+  const m = src.match(/class\s+Solution[\s\S]*?def\s+(\w+)\s*\(self/);
+  return m ? m[1] : null;
+}
+function judge({ slug, lang, code, filter }) {
+  const p = loadProblem(slug);
+  if (!p) throw new Error(`problem not found: ${slug}`);
+  if (!p.expected) return { verdict: "UNSUPPORTED", message: "No reference outputs for this problem (design/interactive/graph problem)." };
+  if (!JUDGE_LANGS.includes(lang)) return { verdict: "UNSUPPORTED", message: `Judge supports: ${JUDGE_LANGS.join(", ")} (C++ judge not built yet).` };
+  const tmp = fs3.mkdtempSync(path3.join(os.tmpdir(), "offcode-"));
+  try {
+    const tests = p.tests.map((t) => t.map(resolveArg));
+    let cmd2, args2;
+    const t0 = Date.now();
+    if (lang === "go") {
+      const sig = parseGoSig(code);
+      if (/^\s*type\s+(ListNode|TreeNode)\b/m.test(code)) throw new Error("Remove your own ListNode/TreeNode type: offcode provides it.");
+      fs3.writeFileSync(path3.join(tmp, "go.mod"), "module offcodejudge\n\ngo 1.18\n");
+      fs3.writeFileSync(path3.join(tmp, "solution.go"), code);
+      fs3.writeFileSync(path3.join(tmp, "harness.go"), goHarness(sig));
+      const b = spawnSync("go", ["build", "-o", path3.join(tmp, process.platform === "win32" ? "sol.exe" : "sol"), "."], { cwd: tmp, encoding: "utf8", timeout: 12e4 });
+      if (b.error) return { verdict: "ERROR", message: b.error.code === "ENOENT" ? "`go` not found in PATH" : b.error.message };
+      if (b.status !== 0) return { verdict: "CE", message: (b.stderr || b.stdout).replace(new RegExp(tmp.replace(/\\/g, "\\\\"), "g"), ".").trim() };
+      cmd2 = path3.join(tmp, process.platform === "win32" ? "sol.exe" : "sol");
+      args2 = [];
+    } else {
+      const fn = pyMethod(code);
+      if (!fn) throw new Error("Python: need `class Solution` with a method");
+      const types = p.params.map((x) => x.type === "boolean" ? "boolean" : x.type);
+      fs3.writeFileSync(path3.join(tmp, "sol.py"), PY_PRE + code + "\n" + PY_POST(fn, types));
+      const cands = process.platform === "win32" ? [["python"], ["py", "-3"], ["python3"]] : [["python3"], ["python"]];
+      const found = cands.find((c) => !spawnSync(c[0], [...c.slice(1), "--version"], { encoding: "utf8" }).error);
+      if (!found) return { verdict: "ERROR", message: "python not found in PATH" };
+      cmd2 = found[0];
+      args2 = [...found.slice(1), path3.join(tmp, "sol.py")];
+    }
+    const r = spawnSync(cmd2, args2, { input: JSON.stringify(tests), encoding: "utf8", env: { ...process.env, PYTHONIOENCODING: "utf-8", PYTHONUTF8: "1" }, windowsHide: true, timeout: TL_MS, maxBuffer: 1 << 28 });
+    if (r.error && r.error.code === "ENOENT") return { verdict: "ERROR", message: `\`${cmd2}\` not found in PATH` };
+    const lines = (r.stdout || "").split(/\r?\n/).filter(Boolean).map((l) => {
+      try {
+        return JSON.parse(l);
+      } catch {
+        return { error: l.slice(0, 200) };
+      }
+    });
+    const timedOut = r.error && r.error.code === "ETIMEDOUT";
+    const results = [];
+    let passed = 0;
+    for (let i = 0; i < tests.length; i++) {
+      const o = lines[i];
+      const input = p.params.map((x, k) => `${x.name} = ${String(tests[i][k]).slice(0, 120)}`).join(", ");
+      const exp = p.expected[i];
+      if (!o) {
+        results.push({ i, status: timedOut ? "TLE" : "RE", input, expected: exp, got: null, error: timedOut ? `exceeded ${TL_MS / 1e3}s` : (r.stderr || "").slice(0, 400) });
+        break;
+      }
+      if (o.error) {
+        results.push({ i, status: "RE", input, expected: exp, got: null, error: o.error });
+        break;
+      }
+      if (same(o.out, exp, p.loose)) {
+        passed++;
+        results.push({ i, status: "AC" });
+      } else {
+        results.push({ i, status: "WA", input, expected: exp, got: o.out });
+        break;
+      }
+    }
+    const fail = results.find((x) => x.status !== "AC");
+    return { verdict: fail ? fail.status : "AC", passed, total: tests.length, ms: Date.now() - t0, fail, results: results.map((x) => x.status) };
+  } catch (e) {
+    return { verdict: "ERROR", message: e.message };
+  } finally {
+    fs3.rmSync(tmp, { recursive: true, force: true });
+  }
+}
+
+// src/progress.js
+import fs4 from "node:fs";
+import os2 from "node:os";
+import path4 from "node:path";
+var file = path4.join(os2.homedir(), ".offcode", "progress.json");
+function loadProgress() {
+  try {
+    return JSON.parse(fs4.readFileSync(file, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function markSolved(slug, lang) {
+  const p = loadProgress();
+  p[slug] = { lang, at: (/* @__PURE__ */ new Date()).toISOString() };
+  fs4.mkdirSync(path4.dirname(file), { recursive: true });
+  fs4.writeFileSync(file, JSON.stringify(p, null, 1));
+}
+
+// src/App.jsx
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+var DIFFS = ["All", "Easy", "Medium", "Hard"];
+var dcolor = (d) => ({ Easy: "green", Medium: "yellow", Hard: "red" })[d];
+var next = (arr, v) => arr[(arr.indexOf(v) + 1) % arr.length];
+function useSize() {
+  const { stdout } = useStdout();
+  const [s, setS] = useState({ w: stdout.columns || 100, h: stdout.rows || 30 });
+  useEffect(() => {
+    const f = () => setS({ w: stdout.columns || 100, h: stdout.rows || 30 });
+    stdout.on("resize", f);
+    return () => stdout.off("resize", f);
+  }, [stdout]);
+  return s;
+}
+function wrap(text, width) {
+  const out = [];
+  for (const raw of text.split("\n")) {
+    let line = raw.replace(/\t/g, "  ");
+    if (!line) {
+      out.push("");
+      continue;
+    }
+    while (line.length > width) {
+      let cut = line.lastIndexOf(" ", width);
+      if (cut < width / 2) cut = width;
+      out.push(line.slice(0, cut));
+      line = line.slice(cut).trimStart();
+    }
+    out.push(line);
+  }
+  return out;
+}
+var Keys = ({ items }) => /* @__PURE__ */ jsx(Box, { children: items.map(([k, v]) => /* @__PURE__ */ jsxs(Box, { marginRight: 2, children: [
+  /* @__PURE__ */ jsx(Text, { bold: true, color: "cyan", children: k }),
+  /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+    " ",
+    v
+  ] })
+] }, k)) });
+function Top({ w, right }) {
+  return /* @__PURE__ */ jsxs(Box, { width: w, justifyContent: "space-between", paddingX: 1, children: [
+    /* @__PURE__ */ jsxs(Text, { bold: true, children: [
+      "offcode ",
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "by Limon Das" })
+    ] }),
+    /* @__PURE__ */ jsx(Text, { dimColor: true, children: right })
+  ] });
+}
+function ListScreen({ onOpen, lang, setLang, progress }) {
+  const { exit } = useApp();
+  const { w, h } = useSize();
+  const [q, setQ] = useState("");
+  const [typing, setTyping] = useState(false);
+  const [diff, setDiff] = useState("All");
+  const [cursor, setCursor] = useState(0);
+  const items = useMemo(() => filterProblems({ q, difficulty: diff }), [q, diff]);
+  const bodyH = Math.max(6, h - 4);
+  const rows = bodyH - 2;
+  const top = Math.min(Math.max(0, cursor - Math.floor(rows / 2)), Math.max(0, items.length - rows));
+  const sel = items[cursor];
+  const leftW = Math.max(38, Math.floor(w * 0.52));
+  const rightW = w - leftW;
+  const preview = useMemo(() => {
+    if (!sel) return [];
+    const p = loadProblem(sel.slug);
+    return wrap(plain(descriptionMd(p)), rightW - 4).slice(0, rows);
+  }, [sel, rightW, rows]);
+  const solved = Object.keys(progress).length;
+  useInput((input, key) => {
+    if (typing) {
+      if (key.return || key.escape) setTyping(false);
+      else if (key.backspace || key.delete) {
+        setQ((s) => s.slice(0, -1));
+        setCursor(0);
+      } else if (input && !key.ctrl && !key.meta) {
+        setQ((s) => s + input);
+        setCursor(0);
+      }
+      return;
+    }
+    if (input === "q") exit();
+    else if (input === "/") setTyping(true);
+    else if (input === "f") {
+      setDiff((d) => next(DIFFS, d));
+      setCursor(0);
+    } else if (input === "l") setLang((l) => next(LANG_KEYS, l));
+    else if (input === "c") {
+      setQ("");
+      setDiff("All");
+      setCursor(0);
+    } else if (key.downArrow || input === "j") setCursor((c) => Math.min(items.length - 1, c + 1));
+    else if (key.upArrow || input === "k") setCursor((c) => Math.max(0, c - 1));
+    else if (key.pageDown) setCursor((c) => Math.min(items.length - 1, c + rows));
+    else if (key.pageUp) setCursor((c) => Math.max(0, c - rows));
+    else if (input === "g") setCursor(0);
+    else if (input === "G") setCursor(items.length - 1);
+    else if (key.return && sel) onOpen(sel.slug);
+  });
+  const titleW = leftW - 4 - 6 - 8 - 4;
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", width: w, height: h - 1, children: [
+    /* @__PURE__ */ jsx(Top, { w, right: `${items.length} problems  ${solved} solved  ${LANGS[lang].label}` }),
+    /* @__PURE__ */ jsxs(Box, { paddingX: 1, children: [
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "search " }),
+      /* @__PURE__ */ jsx(Text, { color: typing ? "cyan" : void 0, children: q || (typing ? "" : "(press /)") }),
+      typing && /* @__PURE__ */ jsx(Text, { color: "cyan", children: "_" }),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "   difficulty " }),
+      /* @__PURE__ */ jsx(Text, { color: dcolor(diff), bold: true, children: diff })
+    ] }),
+    /* @__PURE__ */ jsxs(Box, { height: bodyH, children: [
+      /* @__PURE__ */ jsxs(Box, { width: leftW, borderStyle: "round", borderColor: typing ? "gray" : "cyan", flexDirection: "column", paddingX: 1, children: [
+        items.slice(top, top + rows).map((p, i) => {
+          const on = top + i === cursor;
+          const done = progress[p.slug];
+          return /* @__PURE__ */ jsxs(Box, { children: [
+            /* @__PURE__ */ jsxs(Text, { color: on ? "cyan" : void 0, bold: on, children: [
+              on ? ">" : " ",
+              " "
+            ] }),
+            /* @__PURE__ */ jsx(Text, { color: "green", children: done ? "\u2713" : " " }),
+            /* @__PURE__ */ jsxs(Text, { dimColor: !on, children: [
+              " ",
+              String(p.label).padStart(4),
+              " "
+            ] }),
+            /* @__PURE__ */ jsx(Text, { bold: on, wrap: "truncate-end", children: p.title.padEnd(titleW).slice(0, titleW) }),
+            /* @__PURE__ */ jsxs(Text, { color: dcolor(p.difficulty), children: [
+              " ",
+              p.difficulty.padEnd(6)
+            ] })
+          ] }, p.slug);
+        }),
+        !items.length && /* @__PURE__ */ jsx(Text, { dimColor: true, children: "no match" })
+      ] }),
+      /* @__PURE__ */ jsx(Box, { width: rightW, borderStyle: "round", borderColor: "gray", flexDirection: "column", paddingX: 1, children: sel && /* @__PURE__ */ jsxs(Fragment, { children: [
+        /* @__PURE__ */ jsxs(Text, { bold: true, children: [
+          sel.label,
+          ". ",
+          sel.title
+        ] }),
+        /* @__PURE__ */ jsxs(Text, { children: [
+          /* @__PURE__ */ jsx(Text, { color: dcolor(sel.difficulty), children: sel.difficulty }),
+          /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+            "  ",
+            sel.category,
+            sel.judge ? "" : "  (no judge)"
+          ] })
+        ] }),
+        /* @__PURE__ */ jsx(Text, { children: " " }),
+        preview.slice(0, rows - 3).map((l, i) => /* @__PURE__ */ jsx(Text, { children: l }, i))
+      ] }) })
+    ] }),
+    /* @__PURE__ */ jsx(Box, { paddingX: 1, children: typing ? /* @__PURE__ */ jsx(Keys, { items: [["enter", "done"], ["esc", "done"]] }) : /* @__PURE__ */ jsx(Keys, { items: [["j/k", "move"], ["enter", "open"], ["/", "search"], ["f", "filter"], ["l", "lang"], ["q", "quit"]] }) })
+  ] });
+}
+var TABS = ["description", "hints", "solution", "judge"];
+function Detail({ slug, lang, setLang, onBack, onSolved }) {
+  const { w, h } = useSize();
+  const p = useMemo(() => loadProblem(slug), [slug]);
+  const [tab, setTab] = useState("description");
+  const [scroll, setScroll] = useState(0);
+  const [msg, setMsg] = useState("");
+  const [result, setResult] = useState(null);
+  const [busy, setBusy] = useState(false);
+  const rows = Math.max(5, h - 9);
+  const file2 = solutionPath(p, lang);
+  const lines = useMemo(() => {
+    if (tab === "judge") return [];
+    const md = tab === "description" ? descriptionMd(p) : tab === "hints" ? hintsMd(p) : solutionMd(p);
+    return wrap(plain(md), w - 6);
+  }, [p, tab, w]);
+  const max = Math.max(0, lines.length - rows);
+  function runJudge() {
+    if (!JUDGE_LANGS.includes(lang)) {
+      setResult({ verdict: "UNSUPPORTED", message: `Judge supports go and python. Press l to switch.` });
+      setTab("judge");
+      return;
+    }
+    if (!fs5.existsSync(file2)) {
+      setResult({ verdict: "ERROR", message: `No file yet. Press n to create ${file2}` });
+      setTab("judge");
+      return;
+    }
+    setTab("judge");
+    setBusy(true);
+    setResult(null);
+    setTimeout(() => {
+      const r = judge({ slug, lang, code: fs5.readFileSync(file2, "utf8") });
+      setBusy(false);
+      setResult(r);
+      if (r.verdict === "AC") {
+        markSolved(slug, lang);
+        onSolved();
+      }
+    }, 60);
+  }
+  useInput((input, key) => {
+    if (busy) return;
+    if (key.escape || input === "b") onBack();
+    else if (key.downArrow || input === "j") setScroll((s) => Math.min(max, s + 1));
+    else if (key.upArrow || input === "k") setScroll((s) => Math.max(0, s - 1));
+    else if (key.pageDown || input === " ") setScroll((s) => Math.min(max, s + rows));
+    else if (key.pageUp) setScroll((s) => Math.max(0, s - rows));
+    else if (["1", "2", "3", "4"].includes(input)) {
+      setTab(TABS[Number(input) - 1]);
+      setScroll(0);
+    } else if (key.tab) {
+      setTab((t) => next(TABS, t));
+      setScroll(0);
+    } else if (input === "l") setLang((l) => next(LANG_KEYS, l));
+    else if (input === "n") {
+      try {
+        const r = scaffold(slug, lang);
+        setMsg(`${r.created ? "created" : "exists"}: ${r.file}`);
+      } catch (e) {
+        setMsg(e.message);
+      }
+    } else if (input === "r") runJudge();
+  });
+  const fail = result?.fail;
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", width: w, height: h - 1, children: [
+    /* @__PURE__ */ jsx(Top, { w, right: `${LANGS[lang].label}${p.expected ? "" : "  (no judge)"}` }),
+    /* @__PURE__ */ jsxs(Box, { paddingX: 1, children: [
+      /* @__PURE__ */ jsxs(Text, { bold: true, children: [
+        p.label,
+        ". ",
+        p.title,
+        "  "
+      ] }),
+      /* @__PURE__ */ jsx(Text, { color: dcolor(p.difficulty), children: p.difficulty }),
+      /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+        "  ",
+        p.category
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx(Box, { paddingX: 1, children: TABS.map((t, i) => /* @__PURE__ */ jsx(Box, { marginRight: 1, children: /* @__PURE__ */ jsxs(Text, { inverse: t === tab, bold: t === tab, children: [
+      " ",
+      i + 1,
+      " ",
+      t,
+      " "
+    ] }) }, t)) }),
+    /* @__PURE__ */ jsxs(Box, { borderStyle: "round", borderColor: "gray", flexDirection: "column", paddingX: 1, height: rows + 2, children: [
+      tab !== "judge" && lines.slice(scroll, scroll + rows).map((l, i) => /* @__PURE__ */ jsx(Text, { children: l }, i)),
+      tab === "judge" && /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+        /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+          "file: ",
+          file2
+        ] }),
+        busy && /* @__PURE__ */ jsx(Text, { color: "yellow", children: "judging..." }),
+        !busy && !result && /* @__PURE__ */ jsx(Text, { dimColor: true, children: "press r to run the judge on your file" }),
+        result && /* @__PURE__ */ jsxs(Fragment, { children: [
+          /* @__PURE__ */ jsx(Text, { children: " " }),
+          /* @__PURE__ */ jsxs(Text, { bold: true, color: result.verdict === "AC" ? "green" : "red", children: [
+            result.verdict === "AC" ? "Accepted" : result.verdict,
+            result.total ? `   ${result.passed}/${result.total} tests   ${result.ms} ms` : ""
+          ] }),
+          result.message && wrap(result.message, w - 8).slice(0, rows - 4).map((l, i) => /* @__PURE__ */ jsx(Text, { color: "red", children: l }, i)),
+          fail && /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginTop: 1, children: [
+            /* @__PURE__ */ jsxs(Text, { children: [
+              "test ",
+              fail.i + 1,
+              ": ",
+              fail.status
+            ] }),
+            /* @__PURE__ */ jsx(Text, { dimColor: true, children: "input    " }),
+            /* @__PURE__ */ jsx(Text, { children: fail.input }),
+            fail.expected !== void 0 && /* @__PURE__ */ jsxs(Text, { children: [
+              "expected ",
+              JSON.stringify(fail.expected).slice(0, w - 16)
+            ] }),
+            fail.got !== void 0 && fail.got !== null && /* @__PURE__ */ jsxs(Text, { children: [
+              "got      ",
+              JSON.stringify(fail.got).slice(0, w - 16)
+            ] }),
+            fail.error && /* @__PURE__ */ jsx(Text, { color: "red", children: String(fail.error).slice(0, w - 10) })
+          ] })
+        ] })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx(Box, { paddingX: 1, children: /* @__PURE__ */ jsx(Text, { color: "cyan", children: msg }) }),
+    /* @__PURE__ */ jsx(Box, { paddingX: 1, children: /* @__PURE__ */ jsx(Keys, { items: [["1-4", "tab"], ["j/k", "scroll"], ["n", "new file"], ["r", "run judge"], ["l", "lang"], ["esc", "back"]] }) })
+  ] });
+}
+function App() {
+  const [slug, setSlug] = useState(null);
+  const [lang, setLang] = useState("go");
+  const [progress, setProgress] = useState(loadProgress());
+  return slug ? /* @__PURE__ */ jsx(Detail, { slug, lang, setLang, onBack: () => setSlug(null), onSolved: () => setProgress(loadProgress()) }) : /* @__PURE__ */ jsx(ListScreen, { onOpen: setSlug, lang, setLang, progress });
+}
+
+// src/server.js
+import http from "node:http";
+import fs6 from "node:fs";
+import path5 from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+var here2 = path5.dirname(fileURLToPath2(import.meta.url));
+var webDir = path5.join(here2, "web");
+var MIME = { ".html": "text/html; charset=utf-8", ".js": "text/javascript", ".css": "text/css", ".svg": "image/svg+xml", ".json": "application/json" };
+var send = (res, code, body) => {
+  res.writeHead(code, { "content-type": "application/json" });
+  res.end(JSON.stringify(body));
+};
+var readBody = (req) => new Promise((ok) => {
+  let b = "";
+  req.on("data", (c) => b += c);
+  req.on("end", () => ok(b));
+});
+function startServer({ port = 3e3, host = "127.0.0.1" } = {}) {
+  const server = http.createServer(async (req, res) => {
+    const url = new URL(req.url, `http://${req.headers.host}`);
+    try {
+      if (url.pathname === "/api/meta") return send(res, 200, { categories: allCategories(), progress: loadProgress() });
+      if (url.pathname === "/api/problems") {
+        const items = filterProblems({ q: url.searchParams.get("q") || "", difficulty: url.searchParams.get("difficulty") || "All", category: url.searchParams.get("category") || "" });
+        return send(res, 200, { total: items.length, items });
+      }
+      if (url.pathname.startsWith("/api/problem/")) {
+        const p = loadProblem(decodeURIComponent(url.pathname.slice(13)));
+        if (!p) return send(res, 404, { error: "not found" });
+        return send(res, 200, {
+          slug: p.slug,
+          id: p.label,
+          title: p.title,
+          difficulty: p.difficulty,
+          category: p.category,
+          judge: !!p.expected,
+          starter: p.starter,
+          md: { description: descriptionMd(p), hints: hintsMd(p), solution: solutionMd(p) }
+        });
+      }
+      if (url.pathname === "/api/scaffold" && req.method === "POST") {
+        const { slug, lang } = JSON.parse(await readBody(req) || "{}");
+        return send(res, 200, scaffold(slug, lang in LANGS ? lang : "go"));
+      }
+      if (url.pathname === "/api/judge" && req.method === "POST") {
+        const { slug, lang, code } = JSON.parse(await readBody(req) || "{}");
+        const r = judge({ slug, lang, code });
+        if (r.verdict === "AC") markSolved(slug, lang);
+        return send(res, 200, r);
+      }
+      let rel = url.pathname === "/" ? "/index.html" : url.pathname;
+      const f = path5.join(webDir, path5.normalize(rel).replace(/^(\.\.[/\\])+/, ""));
+      if (!f.startsWith(webDir) || !fs6.existsSync(f) || fs6.statSync(f).isDirectory()) {
+        res.writeHead(404);
+        return res.end("not found");
+      }
+      res.writeHead(200, { "content-type": MIME[path5.extname(f)] || "application/octet-stream" });
+      fs6.createReadStream(f).pipe(res);
+    } catch (e) {
+      send(res, 500, { error: e.message });
+    }
+  });
+  return new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(port, host, () => resolve({ server, url: `http://${host}:${port}` }));
+  });
+}
+
+// src/cli.jsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+var args = process.argv.slice(2);
+var cmd = args[0];
+var flag = (n, d) => {
+  const i = args.indexOf(`--${n}`);
+  return i > -1 ? args[i + 1] : d;
+};
+var HELP = `offcode by Limon Das  (npm: offcode)
+
+  offcode                          terminal UI
+  offcode serve [--port 3000]      web UI
+  offcode list [query]             search problems
+  offcode pick <slug> [--lang go|python|cpp]    create starter file in ./offcode/
+  offcode judge <file>             judge ./offcode/<id>-<slug>/solution.go|py
+  offcode --version
+`;
+if (!cmd) {
+  const out = process.stdout;
+  out.write("\x1B[?1049h\x1B[H");
+  const app = render(/* @__PURE__ */ jsx2(App, {}));
+  app.waitUntilExit().then(() => {
+    out.write("\x1B[?1049l");
+  });
+} else if (cmd === "serve") {
+  startServer({ port: Number(flag("port", 3e3)) }).then(({ url }) => console.log(`offcode web UI: ${url}`)).catch((e) => {
+    console.error(e.message);
+    process.exit(1);
+  });
+} else if (cmd === "list") {
+  for (const p of filterProblems({ q: args[1] || "" }).slice(0, 60))
+    console.log(`${String(p.label).padStart(5)}  ${p.title}  [${p.difficulty}]${p.judge ? "" : "  (no judge)"}`);
+} else if (cmd === "pick") {
+  try {
+    const r = scaffold(args[1], flag("lang", "go"));
+    console.log(`${r.created ? "created" : "exists"}: ${r.file}`);
+  } catch (e) {
+    console.error(e.message, `
+langs: ${LANG_KEYS.join(", ")}`);
+    process.exit(1);
+  }
+} else if (cmd === "judge") {
+  const file2 = args[1];
+  if (!file2 || !fs7.existsSync(file2)) {
+    console.error("usage: offcode judge <file>");
+    process.exit(1);
+  }
+  const slug = path6.basename(path6.dirname(path6.resolve(file2))).replace(/^b?\d+-/, "");
+  const lang = langFromExt(file2);
+  if (!loadProblem(slug)) {
+    console.error(`cannot tell the problem from folder name: ${slug}`);
+    process.exit(1);
+  }
+  const r = judge({ slug, lang, code: fs7.readFileSync(file2, "utf8") });
+  if (r.verdict === "AC") markSolved(slug, lang);
+  console.log(r.verdict === "AC" ? `Accepted  ${r.passed}/${r.total}  ${r.ms} ms` : `${r.verdict}${r.total ? `  ${r.passed}/${r.total}` : ""}`);
+  if (r.message) console.log(r.message);
+  if (r.fail) {
+    console.log(`test ${r.fail.i + 1}: ${r.fail.input}`);
+    if (r.fail.expected !== void 0) console.log(`expected: ${JSON.stringify(r.fail.expected).slice(0, 300)}`);
+    if (r.fail.got !== void 0 && r.fail.got !== null) console.log(`got:      ${JSON.stringify(r.fail.got).slice(0, 300)}`);
+    if (r.fail.error) console.log(r.fail.error);
+  }
+  process.exit(r.verdict === "AC" ? 0 : 1);
+} else if (cmd === "--version" || cmd === "-v") {
+  const here3 = path6.dirname(fileURLToPath3(import.meta.url));
+  console.log(JSON.parse(fs7.readFileSync(path6.join(here3, "..", "package.json"), "utf8")).version);
+} else {
+  console.log(HELP);
+}