@przeprogramowani/10x-cli 1.11.0 → 1.12.0

package/README.md

@@ -49,6 +49,7 @@ Once installed, just tell your agent to **set up 10x-cli** and it will pick up t
 10x get m1l1    # Fetch and apply lesson artifacts
 10x sync        # Update everything you've downloaded; show what changed
 10x doctor      # Check everything is working
+10x bench       # Show the 10xBench top-10 model leaderboard
 ```
 
 ## Commands
@@ -60,6 +61,7 @@ Once installed, just tell your agent to **set up 10x-cli** and it will pick up t
 | `10x get <ref>` | Fetch a lesson and apply artifacts to your workspace |
 | `10x sync` | Bulk-download / refresh lessons and report what changed upstream |
 | `10x doctor` | Diagnose auth, API connectivity, and local config |
+| `10x bench` | Live top-10 AI model leaderboard from [10xbench.ai](https://10xbench.ai) — no login needed |
 
 ### `10x get` Flags
 
@@ -163,6 +165,21 @@ all. **Change visibility covers skills and prompts** — configs are create-only
 conflict is reported, not a failure), `1` if any lesson failed to fetch. The full
 report is still emitted on a partial failure.
 
+### `10x bench`
+
+Shows the [10xBench](https://10xbench.ai) leaderboard — the top 10 AI models
+benchmarked on vibe-coding the Przeprogramowani.pl website — rendered as
+color-coded score bars in your terminal. Public data, works without logging in.
+
+```bash
+10x bench             # Top 10 models with scores, runs, and cost per run
+10x bench --limit 5   # Just the top 5
+10x bench --json      # Machine-readable (also auto-selected when piped)
+```
+
+The data refreshes whenever new benchmark results are published on 10xbench.ai.
+Colors honor `NO_COLOR` and are disabled automatically when output is piped.
+
 ### Global Flags
 
 - `--json` — Machine-readable JSON output (auto-detected when piped)

package/dist/index.mjs

@@ -2271,7 +2271,7 @@ var cac = (name = "") => new CAC(name);
 // package.json
 var package_default = {
   name: "@przeprogramowani/10x-cli",
-  version: "1.11.0",
+  version: "1.12.0",
   description: "Open-source CLI for 10xDevs course content",
   repository: {
     type: "git",
@@ -3262,6 +3262,10 @@ function verbose(ctx, message) {
   process.stderr.write(`[verbose] ${message}
 `);
 }
+function exitNotImplemented(command, phase, flags = {}) {
+  const ctx = resolveContext(flags);
+  outputError(ctx, "not_implemented", `'10x ${command}' lands in ${phase}.`, ExitCodes.ERROR, "See thoughts/shared/plans/2026-04-07-10x-cli-design.md for the full roadmap.");
+}
 
 // src/lib/auth-guard.ts
 var DEFAULT_REFRESH_WINDOW_MS = 5 * 60 * 1000;
@@ -3763,9 +3767,209 @@ function formatRow(entry, rank, name, detail, rankWidth, nameWidth, detailWidth)
   ].join("  ");
 }
 
+// src/commands/bench-kit.ts
+import { spawn } from "node:child_process";
+import {
+  cpSync,
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync3,
+  mkdtempSync,
+  readFileSync as readFileSync2,
+  readdirSync,
+  rmSync as rmSync2,
+  writeFileSync as writeFileSync2
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join as join2, resolve } from "node:path";
+
+// src/lib/experimental.ts
+var EXPERIMENTAL_ENV = "TENX_CLI_EXPERIMENTAL";
+function experimentalEnabled(env = process.env) {
+  const value = env[EXPERIMENTAL_ENV];
+  return value === "1" || value === "true";
+}
+function requireExperimental(command, flags, env = process.env) {
+  if (experimentalEnabled(env))
+    return;
+  const ctx = resolveContext(flags);
+  outputError(ctx, "experimental_locked", `'10x ${command}' is experimental and currently locked.`, ExitCodes.FORBIDDEN, `Set ${EXPERIMENTAL_ENV}=1 and run '10x ${command}' again.`);
+}
+
+// src/commands/bench-kit.ts
+var TEMPLATE_REPO_URL = "https://github.com/przeprogramowani/10x-bench-kit";
+function registerBenchKitCommand(cli) {
+  if (!experimentalEnabled())
+    return;
+  cli.command("bench-kit <action> [dir]", "Manage a benchmark instance (actions: init, update; experimental)").option("--template-version <tag>", "Template tag to install (default: latest)").option("--yes", "Run non-interactively, accepting defaults").example("10x bench-kit init my-benchmark").example("10x bench-kit init my-benchmark --template-version v0.1.0").action(async (action, dir, options) => {
+    requireExperimental(`bench-kit ${action}`, options);
+    const ctx = resolveContext(options);
+    if (action === "init") {
+      await runBenchKitInit(ctx, dir, options);
+      return;
+    }
+    if (action === "update") {
+      exitNotImplemented("bench-kit update", "a later bench-kit phase", options);
+    }
+    outputError(ctx, "unknown_action", `'${action}' is not a bench-kit action.`, ExitCodes.USAGE, "Run '10x bench-kit init [dir]' or '10x bench-kit update'.");
+  });
+}
+async function runBenchKitInit(ctx, dirArg, options, deps = defaultDeps) {
+  const targetDir = resolve(dirArg ?? ".");
+  const requestedRef = normalizeRef(ctx, options.templateVersion);
+  await preflight(ctx, deps);
+  const existingVersion = readInstanceVersion(targetDir);
+  const repair = existingVersion !== null;
+  if (repair && requestedRef !== null) {
+    outputError(ctx, "version_conflict", `This directory already holds a benchmark instance on template version ${existingVersion}.`, ExitCodes.USAGE, "Run '10x bench-kit update' to change the template version of an existing instance.");
+  }
+  if (!repair && existsSync2(targetDir) && readdirSync(targetDir).length > 0) {
+    outputError(ctx, "target_not_empty", `Directory '${targetDir}' is not empty and is not a benchmark instance.`, ExitCodes.ERROR, "Run '10x bench-kit init <dir>' with an empty or new directory.");
+  }
+  const scratch = mkdtempSync(join2(tmpdir(), "bench-kit-"));
+  try {
+    verbose(ctx, `cloning ${TEMPLATE_REPO_URL} (${requestedRef ?? "latest"}) into ${scratch}`);
+    const clone = await deps.cloneTemplate(requestedRef, scratch);
+    if (!clone.ok) {
+      outputError(ctx, "clone_failed", `Could not download the template from ${TEMPLATE_REPO_URL}.`, ExitCodes.ERROR, clone.error ? `Git said: ${clone.error.trim()}` : "Check your internet connection and run '10x bench-kit init' again.");
+    }
+    const templateVersion = readTemplateVersion(ctx, scratch);
+    mkdirSync3(targetDir, { recursive: true });
+    const copied = materialize(scratch, targetDir, { skipExisting: repair });
+    const manifest = {
+      templateVersion,
+      templateRef: requestedRef ?? "latest",
+      templateSource: TEMPLATE_REPO_URL,
+      initializedAt: deps.now().toISOString()
+    };
+    writeFileSync2(join2(targetDir, ".bench-kit", "instance.json"), `${JSON.stringify(manifest, null, 2)}
+`);
+    let committed = false;
+    if (!repair) {
+      committed = await freshGitInit(ctx, deps, targetDir, templateVersion);
+    }
+    const humanLines = repair ? [
+      `Repaired the benchmark instance in '${targetDir}' (template ${templateVersion}).`,
+      `Restored ${copied} missing file${copied === 1 ? "" : "s"}; your tasks, evaluation pool and config were not touched.`
+    ] : [
+      `Created a benchmark instance in '${targetDir}' from template ${templateVersion}.`,
+      committed ? "Initialized a fresh git repository with an initial commit." : "Initialized a fresh git repository (initial commit skipped — commit the files yourself).",
+      "Next: wire up secrets, then run 'bench validate' before the first run."
+    ];
+    output(ctx, humanLines.join(`
+`), {
+      dir: targetDir,
+      mode: repair ? "repair" : "init",
+      templateVersion,
+      templateRef: manifest.templateRef,
+      filesCopied: copied,
+      gitInitialized: !repair,
+      committed
+    });
+  } finally {
+    rmSync2(scratch, { recursive: true, force: true });
+  }
+}
+function normalizeRef(ctx, raw) {
+  if (raw === undefined)
+    return null;
+  const ref = raw.trim();
+  if (ref === "" || ref === "latest")
+    return null;
+  if (!/^[A-Za-z0-9._/-]+$/.test(ref)) {
+    outputError(ctx, "invalid_template_version", `'${raw}' is not a valid template tag.`, ExitCodes.USAGE, "Pass a tag name, for example '10x bench-kit init --template-version v0.1.0'.");
+  }
+  return ref;
+}
+async function preflight(ctx, deps) {
+  if (!await deps.toolAvailable("git")) {
+    outputError(ctx, "preflight_failed", "Git is required to download the template and initialize the instance.", ExitCodes.ERROR, "Install git (https://git-scm.com) and run '10x bench-kit init' again.");
+  }
+  const hasEngine = await deps.toolAvailable("docker") || await deps.toolAvailable("podman");
+  if (!hasEngine) {
+    verbose(ctx, "neither docker nor podman found — benchmark runs will need one later");
+  }
+}
+function readInstanceVersion(dir) {
+  const versionFile = join2(dir, ".bench-kit", "VERSION");
+  if (!existsSync2(versionFile))
+    return null;
+  return readFileSync2(versionFile, "utf8").trim();
+}
+function readTemplateVersion(ctx, cloneDir) {
+  const versionFile = join2(cloneDir, ".bench-kit", "VERSION");
+  if (!existsSync2(versionFile)) {
+    outputError(ctx, "invalid_template", "The downloaded template has no .bench-kit/VERSION file.", ExitCodes.ERROR, "Pass a valid tag via '10x bench-kit init --template-version <tag>'.");
+  }
+  return readFileSync2(versionFile, "utf8").trim();
+}
+function materialize(srcDir, destDir, opts) {
+  let copied = 0;
+  const walk = (rel) => {
+    for (const entry of readdirSync(join2(srcDir, rel), { withFileTypes: true })) {
+      if (rel === "" && entry.name === ".git")
+        continue;
+      const relPath = join2(rel, entry.name);
+      const from = join2(srcDir, relPath);
+      const to = join2(destDir, relPath);
+      if (entry.isDirectory()) {
+        mkdirSync3(to, { recursive: true });
+        walk(relPath);
+        continue;
+      }
+      if (opts.skipExisting && existsSync2(to))
+        continue;
+      cpSync(from, to);
+      copied++;
+    }
+  };
+  walk("");
+  return copied;
+}
+async function freshGitInit(ctx, deps, dir, templateVersion) {
+  const init = await deps.runGit(["init"], dir);
+  if (!init.ok) {
+    outputError(ctx, "git_init_failed", "Could not initialize a git repository in the instance directory.", ExitCodes.ERROR, init.error ? `Git said: ${init.error.trim()}` : undefined);
+  }
+  const add = await deps.runGit(["add", "-A"], dir);
+  const commit = add.ok ? await deps.runGit(["commit", "-m", `chore: bench-kit init (template ${templateVersion})`], dir) : add;
+  if (!commit.ok) {
+    verbose(ctx, `initial commit failed (${commit.error.trim()}) — files are staged, commit manually`);
+    return false;
+  }
+  return true;
+}
+function run(cmd, args, cwd) {
+  return new Promise((resolvePromise) => {
+    const child = spawn(cmd, args, { cwd, stdio: ["ignore", "ignore", "pipe"] });
+    let stderr = "";
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.on("error", (err) => resolvePromise({ ok: false, error: err.message }));
+    child.on("close", (code) => resolvePromise({ ok: code === 0, error: stderr }));
+  });
+}
+var defaultDeps = {
+  async toolAvailable(cmd) {
+    const result = await run(cmd, ["--version"]);
+    return result.ok;
+  },
+  cloneTemplate(ref, destDir) {
+    const args = ["clone", "--depth", "1"];
+    if (ref !== null)
+      args.push("--branch", ref);
+    args.push(TEMPLATE_REPO_URL, destDir);
+    return run("git", args);
+  },
+  runGit(args, cwd) {
+    return run("git", args, cwd);
+  },
+  now: () => new Date
+};
+
 // src/commands/doctor.ts
-import { existsSync as existsSync2, accessSync, constants } from "node:fs";
-import { join as join2 } from "node:path";
+import { existsSync as existsSync3, accessSync, constants } from "node:fs";
+import { join as join3 } from "node:path";
 
 // src/lib/signing.ts
 import { createHash, createPublicKey, verify } from "node:crypto";
@@ -4261,7 +4465,7 @@ async function checkApiConnectivity() {
 }
 function checkConfigDirectory() {
   const dir = configDir();
-  if (!existsSync2(dir)) {
+  if (!existsSync3(dir)) {
     return {
       name: "config",
       label: "Config",
@@ -4326,8 +4530,8 @@ function checkToolDirectory() {
   const toolId = readToolConfig()?.tool ?? DEFAULT_TOOL;
   const profile = PROFILES[toolId] ?? PROFILES[DEFAULT_TOOL];
   const dirName = profile.manifestDir;
-  const toolDir = join2(cwd, dirName);
-  if (!existsSync2(toolDir)) {
+  const toolDir = join3(cwd, dirName);
+  if (!existsSync3(toolDir)) {
     return {
       name: "tool-dir",
       label: profile.displayName,
@@ -4359,7 +4563,7 @@ function checkToolDirectory() {
 }
 
 // src/commands/get.ts
-import { join as join7 } from "node:path";
+import { join as join8 } from "node:path";
 
 // src/lib/conflict-prompt.ts
 function createConflictResolver(tty) {
@@ -4444,8 +4648,8 @@ function parseModuleRef(raw) {
 
 // src/lib/manifest.ts
 import { createHash as createHash2 } from "node:crypto";
-import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync2, renameSync as renameSync2, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "node:fs";
-import { dirname as dirname2, join as join3 } from "node:path";
+import { existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync3, renameSync as renameSync2, rmSync as rmSync3, writeFileSync as writeFileSync3 } from "node:fs";
+import { dirname as dirname2, join as join4 } from "node:path";
 var MANIFEST_FILENAME = ".10x-cli-manifest.json";
 var CLI_PACKAGE_NAME = "@przeprogramowani/10x-cli";
 var MANIFEST_VERSION = 3;
@@ -4453,12 +4657,12 @@ function contentHash(content) {
   return createHash2("sha256").update(content, "utf8").digest("hex");
 }
 function readManifest(dir) {
-  const manifestPath = join3(dir, MANIFEST_FILENAME);
-  if (!existsSync3(manifestPath))
+  const manifestPath = join4(dir, MANIFEST_FILENAME);
+  if (!existsSync4(manifestPath))
     return null;
   let raw;
   try {
-    raw = readFileSync2(manifestPath, "utf8");
+    raw = readFileSync3(manifestPath, "utf8");
   } catch {
     return null;
   }
@@ -4473,14 +4677,14 @@ function readManifest(dir) {
   return parsed;
 }
 function writeManifest(dir, manifest) {
-  if (!existsSync3(dir)) {
-    mkdirSync3(dir, { recursive: true });
+  if (!existsSync4(dir)) {
+    mkdirSync4(dir, { recursive: true });
   }
-  const manifestPath = join3(dir, MANIFEST_FILENAME);
-  mkdirSync3(dirname2(manifestPath), { recursive: true });
+  const manifestPath = join4(dir, MANIFEST_FILENAME);
+  mkdirSync4(dirname2(manifestPath), { recursive: true });
   const tmp = `${manifestPath}.tmp`;
-  rmSync2(tmp, { force: true });
-  writeFileSync2(tmp, `${JSON.stringify(manifest, null, 2)}
+  rmSync3(tmp, { force: true });
+  writeFileSync3(tmp, `${JSON.stringify(manifest, null, 2)}
 `);
   renameSync2(tmp, manifestPath);
 }
@@ -4580,10 +4784,10 @@ function buildUnionFiles(lessons) {
 }
 
 // src/lib/tool-detect.ts
-import { existsSync as existsSync4 } from "node:fs";
-import { join as join4 } from "node:path";
+import { existsSync as existsSync5 } from "node:fs";
+import { join as join5 } from "node:path";
 function detectTools(projectRoot) {
-  const hit = (rel) => existsSync4(join4(projectRoot, rel));
+  const hit = (rel) => existsSync5(join5(projectRoot, rel));
   const signals = [];
   if (hit(".claude/" + MANIFEST_FILENAME)) {
     signals.push({
@@ -4691,23 +4895,23 @@ function topDetectedProfile(signals) {
 
 // src/lib/tool-switch.ts
 import {
-  existsSync as existsSync6,
+  existsSync as existsSync7,
   lstatSync,
-  mkdirSync as mkdirSync5,
-  readFileSync as readFileSync5,
+  mkdirSync as mkdirSync6,
+  readFileSync as readFileSync6,
   renameSync as renameSync3,
   rmdirSync as rmdirSync2,
-  rmSync as rmSync4,
+  rmSync as rmSync5,
   statSync,
-  writeFileSync as writeFileSync4
+  writeFileSync as writeFileSync5
 } from "node:fs";
-import { dirname as dirname4, join as join6 } from "node:path";
+import { dirname as dirname4, join as join7 } from "node:path";
 
 // src/lib/fs-utils.ts
-import { readFileSync as readFileSync3 } from "node:fs";
+import { readFileSync as readFileSync4 } from "node:fs";
 function readFileOrNull(path) {
   try {
-    return readFileSync3(path, "utf8");
+    return readFileSync4(path, "utf8");
   } catch {
     return null;
   }
@@ -4783,15 +4987,15 @@ function stripBlock(content, begin, end, label, warnings) {
 // src/lib/writer.ts
 import {
   chmodSync as chmodSync2,
-  existsSync as existsSync5,
-  mkdirSync as mkdirSync4,
-  readFileSync as readFileSync4,
-  readdirSync,
+  existsSync as existsSync6,
+  mkdirSync as mkdirSync5,
+  readFileSync as readFileSync5,
+  readdirSync as readdirSync2,
   rmdirSync,
-  rmSync as rmSync3,
-  writeFileSync as writeFileSync3
+  rmSync as rmSync4,
+  writeFileSync as writeFileSync4
 } from "node:fs";
-import { dirname as dirname3, join as join5 } from "node:path";
+import { dirname as dirname3, join as join6 } from "node:path";
 var CLI_VERSION = package_default.version;
 var DEFAULT_COURSE = "10xdevs3";
 async function applyBundle(bundle, projectRoot, options = {}) {
@@ -4801,7 +5005,7 @@ async function applyBundle(bundle, projectRoot, options = {}) {
   const profile = options.profile ?? PROFILES[DEFAULT_TOOL];
   const onConflict = options.onConflict;
   const applyCourseRules = options.applyCourseRules !== false;
-  const manifestDir = join5(projectRoot, profile.manifestDir);
+  const manifestDir = join6(projectRoot, profile.manifestDir);
   const prevManifest = readManifest(manifestDir);
   const plan = planBundle(bundle, projectRoot, { profile, applyCourseRules });
   const nextSkillHashes = {};
@@ -4903,7 +5107,7 @@ async function applyBundle(bundle, projectRoot, options = {}) {
     }
     prompts.push({ name: prompt.name, path: target, action: finalAction, userBackupPath });
   }
-  const rulesFilePath = join5(projectRoot, profile.rulesFile);
+  const rulesFilePath = join6(projectRoot, profile.rulesFile);
   const existingRules = readFileOrEmpty(rulesFilePath);
   const { action: rulesAction, content: newRulesContent } = planRules(existingRules, bundle, profile, applyCourseRules);
   if (!dryRun && rulesAction !== "unchanged") {
@@ -4925,24 +5129,24 @@ async function applyBundle(bundle, projectRoot, options = {}) {
   for (const entry of removed.skillDirs) {
     removalResult.skills.push({ name: entry.name, path: entry.path, action: "removed" });
     if (!dryRun && !partial)
-      rmSync3(entry.path, { recursive: true, force: true });
+      rmSync4(entry.path, { recursive: true, force: true });
   }
   for (const entry of removed.skillFiles) {
     removalResult.skills.push({ name: entry.name, path: entry.path, action: "removed" });
     if (!dryRun && !partial) {
-      rmSync3(entry.path, { force: true });
+      rmSync4(entry.path, { force: true });
       removeEmptyParentDirs(entry.path, entry.skillDirAbs);
     }
   }
   for (const entry of removed.prompts) {
     removalResult.prompts.push({ name: entry.name, path: entry.path, action: "removed" });
     if (!dryRun && !partial)
-      rmSync3(entry.path, { force: true });
+      rmSync4(entry.path, { force: true });
   }
   for (const entry of removed.configs) {
     removalResult.configs.push({ name: entry.name, path: entry.path, action: "removed" });
     if (!dryRun && !partial)
-      rmSync3(entry.path, { force: true });
+      rmSync4(entry.path, { force: true });
   }
   if (!dryRun && !partial) {
     const catalogContentHash = options.catalogContentHash ?? prevManifest?.lessons?.[bundle.lessonId]?.catalogContentHash;
@@ -5023,13 +5227,13 @@ function planBundle(bundle, projectRoot, options = {}) {
     assertSafeName(prompt.name, "prompt");
   for (const config of bundle.configs)
     assertSafeName(config.name, "config");
-  const manifestDir = join5(projectRoot, profile.manifestDir);
+  const manifestDir = join6(projectRoot, profile.manifestDir);
   const prevManifest = readManifest(manifestDir);
   const skills = bundle.skills.map((skill) => {
-    const skillDir = join5(projectRoot, profile.skillDir(skill.name));
+    const skillDir = join6(projectRoot, profile.skillDir(skill.name));
     const prevEntry = prevManifest?.files.skills[skill.name];
     const files = skill.files.map((file) => {
-      const target = join5(skillDir, file.path);
+      const target = join6(skillDir, file.path);
       const storedHash = prevEntry?.contentHashes?.[file.path];
       const { action, isConflict } = computeFileAction(target, file.content, storedHash);
       return {
@@ -5043,7 +5247,7 @@ function planBundle(bundle, projectRoot, options = {}) {
     return { name: skill.name, files };
   });
   const prompts = bundle.prompts.map((prompt) => {
-    const target = join5(projectRoot, profile.promptPath(prompt.name));
+    const target = join6(projectRoot, profile.promptPath(prompt.name));
     const storedHash = prevManifest?.files.promptHashes?.[`${prompt.name}.md`];
     const { action, isConflict } = computeFileAction(target, prompt.content, storedHash);
     return {
@@ -5054,12 +5258,12 @@ function planBundle(bundle, projectRoot, options = {}) {
       upstreamChanged: computeUpstreamChanged(prompt.content, storedHash, action)
     };
   });
-  const rulesFilePath = join5(projectRoot, profile.rulesFile);
+  const rulesFilePath = join6(projectRoot, profile.rulesFile);
   const existingRules = readFileOrEmpty(rulesFilePath);
   const { action: rulesAction } = planRules(existingRules, bundle, profile, applyCourseRules);
   const configs = bundle.configs.map((config) => {
-    const target = join5(projectRoot, profile.configPath(config.name));
-    const action = existsSync5(target) ? "skipped" : "created";
+    const target = join6(projectRoot, profile.configPath(config.name));
+    const action = existsSync6(target) ? "skipped" : "created";
     return {
       name: config.name,
       path: target,
@@ -5113,11 +5317,11 @@ function planRules(existingRules, bundle, profile, applyCourseRules) {
   return { action, content: newRules };
 }
 function computeFileAction(filePath, newContent, storedHash) {
-  if (!existsSync5(filePath))
+  if (!existsSync6(filePath))
     return { action: "created", isConflict: false };
   let current;
   try {
-    current = readFileSync4(filePath, "utf8");
+    current = readFileSync5(filePath, "utf8");
   } catch {
     return { action: "updated", isConflict: false };
   }
@@ -5138,21 +5342,21 @@ function buildUserBackupPath(filePath) {
   return `${filePath.slice(0, lastDot)}.user${filePath.slice(lastDot)}`;
 }
 function copyFileSync(src, dest) {
-  mkdirSync4(dirname3(dest), { recursive: true });
-  writeFileSync3(dest, readFileSync4(src));
+  mkdirSync5(dirname3(dest), { recursive: true });
+  writeFileSync4(dest, readFileSync5(src));
 }
 function readFileOrEmpty(filePath) {
-  if (!existsSync5(filePath))
+  if (!existsSync6(filePath))
     return "";
   try {
-    return readFileSync4(filePath, "utf8");
+    return readFileSync5(filePath, "utf8");
   } catch {
     return "";
   }
 }
 function writeFileAt(filePath, content) {
-  mkdirSync4(dirname3(filePath), { recursive: true });
-  writeFileSync3(filePath, content);
+  mkdirSync5(dirname3(filePath), { recursive: true });
+  writeFileSync4(filePath, content);
 }
 function computeRemovals(prevManifest, bundle, profile, projectRoot) {
   const empty = {
@@ -5195,7 +5399,7 @@ function computeRemovals(prevManifest, bundle, profile, projectRoot) {
   for (const [skillName, skill] of Object.entries(prevLessonEntry.skills)) {
     if (!isSafeName(skillName))
       continue;
-    const skillDirAbs = join5(projectRoot, profile.skillDir(skillName));
+    const skillDirAbs = join6(projectRoot, profile.skillDir(skillName));
     if (!currentSkills.has(skillName)) {
       if (protectedSkills.has(skillName)) {
         const prot = protectedSkills.get(skillName);
@@ -5206,7 +5410,7 @@ function computeRemovals(prevManifest, bundle, profile, projectRoot) {
             continue;
           removed.skillFiles.push({
             name: `${skillName}/${relPath}`,
-            path: join5(skillDirAbs, relPath),
+            path: join6(skillDirAbs, relPath),
             skillDirAbs
           });
         }
@@ -5225,7 +5429,7 @@ function computeRemovals(prevManifest, bundle, profile, projectRoot) {
         continue;
       removed.skillFiles.push({
         name: `${skillName}/${relPath}`,
-        path: join5(skillDirAbs, relPath),
+        path: join6(skillDirAbs, relPath),
         skillDirAbs
       });
     }
@@ -5240,7 +5444,7 @@ function computeRemovals(prevManifest, bundle, profile, projectRoot) {
     const promptName = promptFile.replace(/\.md$/, "");
     removed.prompts.push({
       name: promptFile,
-      path: join5(projectRoot, profile.promptPath(promptName))
+      path: join6(projectRoot, profile.promptPath(promptName))
     });
   }
   for (const configFile of prevLessonEntry.configs) {
@@ -5252,7 +5456,7 @@ function computeRemovals(prevManifest, bundle, profile, projectRoot) {
       continue;
     removed.configs.push({
       name: configFile,
-      path: join5(projectRoot, profile.configPath(configFile))
+      path: join6(projectRoot, profile.configPath(configFile))
     });
   }
   return removed;
@@ -5261,7 +5465,7 @@ function removeEmptyParentDirs(filePath, skillDirAbs) {
   let dir = dirname3(filePath);
   while (dir.startsWith(skillDirAbs) && dir !== skillDirAbs) {
     try {
-      if (readdirSync(dir).length > 0)
+      if (readdirSync2(dir).length > 0)
         return;
       rmdirSync(dir);
     } catch {
@@ -5275,10 +5479,10 @@ function findOrphanedManifests(projectRoot, currentProfile) {
   for (const profile of Object.values(PROFILES)) {
     if (profile.toolId === currentProfile.toolId)
       continue;
-    const manifestPath = join5(projectRoot, profile.manifestDir, MANIFEST_FILENAME);
-    if (!existsSync5(manifestPath))
+    const manifestPath = join6(projectRoot, profile.manifestDir, MANIFEST_FILENAME);
+    if (!existsSync6(manifestPath))
       continue;
-    const manifest = readManifest(join5(projectRoot, profile.manifestDir));
+    const manifest = readManifest(join6(projectRoot, profile.manifestDir));
     if (!manifest)
       continue;
     out.push({ profile, manifestPath, manifest });
@@ -5357,8 +5561,8 @@ function migrateArtifacts(projectRoot, orphan, newProfile) {
       summary.skipped.push({ path: skillName, reason: "unsafe name in manifest" });
       continue;
     }
-    const fromSkillDir = join6(projectRoot, oldProfile.skillDir(skillName));
-    const toSkillDir = join6(projectRoot, newProfile.skillDir(skillName));
+    const fromSkillDir = join7(projectRoot, oldProfile.skillDir(skillName));
+    const toSkillDir = join7(projectRoot, newProfile.skillDir(skillName));
     let anyMoved = false;
     for (const relPath of entry.files) {
       if (!isSafeSkillFilePath(relPath)) {
@@ -5368,8 +5572,8 @@ function migrateArtifacts(projectRoot, orphan, newProfile) {
         });
         continue;
       }
-      const from = join6(fromSkillDir, relPath);
-      const to = join6(toSkillDir, relPath);
+      const from = join7(fromSkillDir, relPath);
+      const to = join7(toSkillDir, relPath);
       if (moveIfSafe(from, to, summary.skipped))
         anyMoved = true;
     }
@@ -5383,8 +5587,8 @@ function migrateArtifacts(projectRoot, orphan, newProfile) {
       continue;
     }
     const promptName = promptFile.replace(/\.md$/, "");
-    const from = join6(projectRoot, oldProfile.promptPath(promptName));
-    const to = join6(projectRoot, newProfile.promptPath(promptName));
+    const from = join7(projectRoot, oldProfile.promptPath(promptName));
+    const to = join7(projectRoot, newProfile.promptPath(promptName));
     if (moveIfSafe(from, to, summary.skipped)) {
       summary.movedOrRemoved.prompts.push(promptFile);
     }
@@ -5394,15 +5598,15 @@ function migrateArtifacts(projectRoot, orphan, newProfile) {
       summary.skipped.push({ path: configFile, reason: "unsafe name in manifest" });
       continue;
     }
-    const from = join6(projectRoot, oldProfile.configPath(configFile));
-    const to = join6(projectRoot, newProfile.configPath(configFile));
+    const from = join7(projectRoot, oldProfile.configPath(configFile));
+    const to = join7(projectRoot, newProfile.configPath(configFile));
     if (moveIfSafe(from, to, summary.skipped)) {
       summary.movedOrRemoved.configs.push(configFile);
     }
   }
   summary.sentinelStripped = stripSentinelFromRulesFile(projectRoot, oldProfile);
-  rmSync4(orphan.manifestPath, { force: true });
-  tryRemoveEmptyDir(join6(projectRoot, oldProfile.manifestDir));
+  rmSync5(orphan.manifestPath, { force: true });
+  tryRemoveEmptyDir(join7(projectRoot, oldProfile.manifestDir));
   return summary;
 }
 function deleteArtifacts(projectRoot, orphan) {
@@ -5419,7 +5623,7 @@ function deleteArtifacts(projectRoot, orphan) {
       summary.skipped.push({ path: skillName, reason: "unsafe name in manifest" });
       continue;
     }
-    const skillDir = join6(projectRoot, oldProfile.skillDir(skillName));
+    const skillDir = join7(projectRoot, oldProfile.skillDir(skillName));
     for (const relPath of entry.files) {
       if (!isSafeSkillFilePath(relPath)) {
         summary.skipped.push({
@@ -5428,9 +5632,9 @@ function deleteArtifacts(projectRoot, orphan) {
         });
         continue;
       }
-      rmSync4(join6(skillDir, relPath), { force: true });
+      rmSync5(join7(skillDir, relPath), { force: true });
     }
-    rmSync4(skillDir, { recursive: true, force: true });
+    rmSync5(skillDir, { recursive: true, force: true });
     summary.movedOrRemoved.skills.push(skillName);
   }
   for (const promptFile of orphan.manifest.files.prompts) {
@@ -5439,7 +5643,7 @@ function deleteArtifacts(projectRoot, orphan) {
       continue;
     }
     const promptName = promptFile.replace(/\.md$/, "");
-    rmSync4(join6(projectRoot, oldProfile.promptPath(promptName)), { force: true });
+    rmSync5(join7(projectRoot, oldProfile.promptPath(promptName)), { force: true });
     summary.movedOrRemoved.prompts.push(promptFile);
   }
   for (const configFile of orphan.manifest.files.configs) {
@@ -5447,27 +5651,27 @@ function deleteArtifacts(projectRoot, orphan) {
       summary.skipped.push({ path: configFile, reason: "unsafe name in manifest" });
       continue;
     }
-    rmSync4(join6(projectRoot, oldProfile.configPath(configFile)), { force: true });
+    rmSync5(join7(projectRoot, oldProfile.configPath(configFile)), { force: true });
     summary.movedOrRemoved.configs.push(configFile);
   }
   summary.sentinelStripped = stripSentinelFromRulesFile(projectRoot, oldProfile);
-  rmSync4(orphan.manifestPath, { force: true });
-  const manifestDirAbs = join6(projectRoot, oldProfile.manifestDir);
-  tryRemoveEmptyDir(join6(manifestDirAbs, "skills"));
-  tryRemoveEmptyDir(join6(manifestDirAbs, "prompts"));
-  tryRemoveEmptyDir(join6(manifestDirAbs, "config-templates"));
+  rmSync5(orphan.manifestPath, { force: true });
+  const manifestDirAbs = join7(projectRoot, oldProfile.manifestDir);
+  tryRemoveEmptyDir(join7(manifestDirAbs, "skills"));
+  tryRemoveEmptyDir(join7(manifestDirAbs, "prompts"));
+  tryRemoveEmptyDir(join7(manifestDirAbs, "config-templates"));
   tryRemoveEmptyDir(manifestDirAbs);
   return summary;
 }
 function moveIfSafe(from, to, skipped) {
-  if (!existsSync6(from)) {
+  if (!existsSync7(from)) {
     return false;
   }
   if (lstatSync(from).isSymbolicLink()) {
     skipped.push({ path: from, reason: "source is a symlink" });
     return false;
   }
-  if (existsSync6(to)) {
+  if (existsSync7(to)) {
     if (!filesAreIdentical(from, to)) {
       skipped.push({
         path: to,
@@ -5475,22 +5679,22 @@ function moveIfSafe(from, to, skipped) {
       });
       return false;
     }
-    rmSync4(from, { force: true });
+    rmSync5(from, { force: true });
     return true;
   }
-  mkdirSync5(dirname4(to), { recursive: true });
+  mkdirSync6(dirname4(to), { recursive: true });
   try {
     renameSync3(from, to);
   } catch (err) {
     const code = err?.code;
     if (code !== "EXDEV")
       throw err;
-    const bytes = readFileSync5(from);
+    const bytes = readFileSync6(from);
     const tmp = `${to}.tmp`;
-    writeFileSync4(tmp, bytes);
+    writeFileSync5(tmp, bytes);
     renameSync3(tmp, to);
     try {
-      rmSync4(from, { force: true });
+      rmSync5(from, { force: true });
     } catch {
       skipped.push({
         path: from,
@@ -5502,8 +5706,8 @@ function moveIfSafe(from, to, skipped) {
   return true;
 }
 function stripSentinelFromRulesFile(projectRoot, oldProfile) {
-  const rulesPath = join6(projectRoot, oldProfile.rulesFile);
-  if (!existsSync6(rulesPath))
+  const rulesPath = join7(projectRoot, oldProfile.rulesFile);
+  if (!existsSync7(rulesPath))
     return false;
   const existing = readFileOrNull(rulesPath);
   if (existing === null)
@@ -5512,9 +5716,9 @@ function stripSentinelFromRulesFile(projectRoot, oldProfile) {
   if (!removed)
     return false;
   if (content.trim().length === 0) {
-    rmSync4(rulesPath, { force: true });
+    rmSync5(rulesPath, { force: true });
   } else {
-    writeFileSync4(rulesPath, content);
+    writeFileSync5(rulesPath, content);
   }
   return true;
 }
@@ -5524,13 +5728,13 @@ function filesAreIdentical(a2, b2) {
     const bStat = statSync(b2);
     if (aStat.size !== bStat.size)
       return false;
-    return readFileSync5(a2).equals(readFileSync5(b2));
+    return readFileSync6(a2).equals(readFileSync6(b2));
   } catch {
     return false;
   }
 }
 function tryRemoveEmptyDir(dir) {
-  if (!existsSync6(dir))
+  if (!existsSync7(dir))
     return;
   try {
     rmdirSync2(dir);
@@ -5737,7 +5941,7 @@ async function runGet(ctx, ref, options) {
   const isFiltered = options.type !== undefined;
   const bundle = filterBundle(ctx, result.data, options);
   const isTTY = process.stdout.isTTY === true;
-  const prevManifest = readManifest(join7(process.cwd(), profile.manifestDir));
+  const prevManifest = readManifest(join8(process.cwd(), profile.manifestDir));
   if (prevManifest && prevManifest.manifestVersion === 2) {
     showUpgradeNotice(isTTY);
   }
@@ -6107,7 +6311,7 @@ function renderModuleDetail(ctx, module) {
 }
 
 // src/commands/sync.ts
-import { join as join8 } from "node:path";
+import { join as join9 } from "node:path";
 var DEFAULT_COURSE4 = "10xdevs3";
 var SUPPORTED_LANGS = ["en", "pl"];
 function registerSyncCommand(cli) {
@@ -6153,7 +6357,7 @@ async function runSync(ctx, options) {
     }
     return true;
   });
-  const manifest = readManifest(join8(process.cwd(), profile.manifestDir));
+  const manifest = readManifest(join9(process.cwd(), profile.manifestDir));
   const manifestLessonIds = new Set(manifest?.lessons ? Object.keys(manifest.lessons) : []);
   let targets = unlocked;
   if (moduleFilter !== undefined)
@@ -6518,6 +6722,7 @@ registerListCommand(cli);
 registerSyncCommand(cli);
 registerDoctorCommand(cli);
 registerBenchCommand(cli);
+registerBenchKitCommand(cli);
 cli.help();
 cli.version(package_default.version);
 try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@przeprogramowani/10x-cli",
-  "version": "1.11.0",
+  "version": "1.12.0",
   "description": "Open-source CLI for 10xDevs course content",
   "repository": {
     "type": "git",

package/skills/10x-cli-guide/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: 10x-cli-guide
-description: "Invoke this skill when the user asks how to USE the 10x-cli day-to-day — fetching lessons, listing modules, switching AI tools, troubleshooting errors, understanding where artifacts land, or working on a specific OS (Windows, Linux, macOS). Covers commands (get, list, doctor, auth --status/--logout), tool profiles, artifact locations, common errors, and platform-specific tips. Excludes: first-time installation and onboarding (use 10x-cli-setup instead), developing or contributing to 10x-cli source code, and general programming help."
+description: "Invoke this skill when the user asks how to USE the 10x-cli day-to-day — fetching lessons, listing modules, switching AI tools, troubleshooting errors, understanding where artifacts land, checking the 10xBench model leaderboard, or working on a specific OS (Windows, Linux, macOS). Covers commands (get, list, doctor, auth --status/--logout, bench), tool profiles, artifact locations, common errors, and platform-specific tips. Excludes: first-time installation and onboarding (use 10x-cli-setup instead), developing or contributing to 10x-cli source code, and general programming help."
 ---
 
 # 10x-cli Daily Usage Guide
@@ -117,6 +117,22 @@ Exit code 78 means at least one check failed.
 
 Sessions refresh transparently — if a token is near expiry, the next command refreshes it automatically. You only need to re-auth manually if the session has fully expired.
 
+### `10x bench` — 10xBench model leaderboard
+
+```bash
+10x bench             # Top 10 AI models with color-coded score bars
+10x bench --limit 5   # Just the top 5
+10x bench --json      # Machine-readable envelope (also when piped)
+```
+
+Shows the live leaderboard from [10xbench.ai](https://10xbench.ai) — AI models
+benchmarked on vibe-coding the Przeprogramowani.pl website. Each row has the
+average score, number of runs, cost per run where measured, and the agent
+harness used. **No authentication needed** — this works before `10x auth`.
+Data updates when new benchmark results are published; superseded model
+versions are already filtered out upstream. If it reports the leaderboard as
+unavailable, the site may be mid-deploy — retry in a few minutes.
+
 ---
 
 ## Switching Tools