librian 0.1.0 → 0.1.2

package/dist/cli.js

@@ -2985,7 +2985,7 @@ var require_compile = __commonJS({
       const schOrFunc = root.refs[ref];
       if (schOrFunc)
         return schOrFunc;
-      let _sch = resolve7.call(this, root, ref);
+      let _sch = resolve6.call(this, root, ref);
       if (_sch === void 0) {
         const schema = (_a3 = root.localRefs) === null || _a3 === void 0 ? void 0 : _a3[ref];
         const { schemaId } = this.opts;
@@ -3012,7 +3012,7 @@ var require_compile = __commonJS({
     function sameSchemaEnv(s1, s2) {
       return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
     }
-    function resolve7(root, ref) {
+    function resolve6(root, ref) {
       let sch;
       while (typeof (sch = this.refs[ref]) == "string")
         ref = sch;
@@ -3872,11 +3872,11 @@ var require_fast_uri = __commonJS({
         normalizeString(uri, options);
       } else if (typeof uri === "object") {
         uri = /** @type {T} */
-        parse3(serialize(uri, options), options);
+        parse4(serialize(uri, options), options);
       }
       return uri;
     }
-    function resolve7(baseURI, relativeURI, options) {
+    function resolve6(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
       const {
         parsed: baseParsed,
@@ -3915,8 +3915,8 @@ var require_fast_uri = __commonJS({
     function resolveComponent(base, relative3, options, skipNormalization) {
       const target = {};
       if (!skipNormalization) {
-        base = parse3(serialize(base, options), options);
-        relative3 = parse3(serialize(relative3, options), options);
+        base = parse4(serialize(base, options), options);
+        relative3 = parse4(serialize(relative3, options), options);
       }
       options = options || {};
       if (!options.tolerant && relative3.scheme) {
@@ -4234,7 +4234,7 @@ var require_fast_uri = __commonJS({
       }
       return { parsed, malformedAuthorityOrPort, malformedPercentEncoding, malformedSchemeSpecific, malformedHost, malformedScheme };
     }
-    function parse3(uri, opts) {
+    function parse4(uri, opts) {
       return parseWithStatus(uri, opts).parsed;
     }
     function normalizeString(uri, opts) {
@@ -4267,11 +4267,11 @@ var require_fast_uri = __commonJS({
     var fastUri = {
       SCHEMES,
       normalize: normalize2,
-      resolve: resolve7,
+      resolve: resolve6,
       resolveComponent,
       equal,
       serialize,
-      parse: parse3
+      parse: parse4
     };
     module.exports = fastUri;
     module.exports.default = fastUri;
@@ -7258,12 +7258,12 @@ var require_dist = __commonJS({
 
 // src/cli.ts
 import { statSync as statSync5 } from "node:fs";
-import { resolve as resolve6 } from "node:path";
+import { resolve as resolve5 } from "node:path";
 
 // package.json
 var package_default = {
   name: "librian",
-  version: "0.1.0",
+  version: "0.1.2",
   description: "Find and read sections of a markdown docs folder over MCP, with outlines and line ranges that stay current as the docs change",
   repository: {
     type: "git",
@@ -7331,6 +7331,8 @@ var TITLE_MAX_CHARS = 80;
 var EXCERPT_BYTES = 160;
 var SEARCH_LIMIT_DEFAULT = 20;
 var SEARCH_LIMIT_MAX = 50;
+var COUNT_MAX_FILES = 5e3;
+var COUNT_MAX_MS = 2e3;
 
 // src/modules/catalog/catalog.ts
 var CATALOG_FILE_NAME = "catalog.json";
@@ -7456,9 +7458,10 @@ function defaultEntryName(root, taken) {
   }
 }
 
-// src/modules/docs/library.ts
-import { readFileSync as readFileSync2, readdirSync, realpathSync, statSync } from "node:fs";
-import { basename, join as join2, resolve } from "node:path";
+// src/modules/cli/folder-check.ts
+import { statSync as statSync2 } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { join as join3, parse, resolve as resolve2 } from "node:path";
 
 // src/_libs/compare-text.ts
 function compareText(left, right) {
@@ -7491,6 +7494,10 @@ function compareText(left, right) {
   return 0;
 }
 
+// src/modules/docs/library.ts
+import { readFileSync as readFileSync2, readdirSync, realpathSync, statSync } from "node:fs";
+import { basename, join as join2, resolve } from "node:path";
+
 // src/_libs/is-inside.ts
 import { isAbsolute, relative, sep } from "node:path";
 function isInside(root, target) {
@@ -7682,18 +7689,10 @@ var ALWAYS_EXCLUDED_DIRECTORY = "node_modules";
 function normalizeExclude(entry) {
   return entry.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/+$/, "");
 }
-function openLibrary(options) {
-  const root = realpathSync.native(resolve(options.root));
-  if (statSync(root).isDirectory() == false) {
-    throw new Error("root is not a folder: " + root);
-  }
-  let name = basename(root);
-  if (name == "") {
-    name = root;
-  }
+function listMarkdownPaths(root, exclude, limits) {
   const excludedNames = /* @__PURE__ */ new Set();
   const excludedPaths = /* @__PURE__ */ new Set();
-  for (const entry of options.exclude) {
+  for (const entry of exclude) {
     const normalized = normalizeExclude(entry);
     if (normalized == "") {
       continue;
@@ -7704,43 +7703,65 @@ function openLibrary(options) {
       excludedNames.add(normalized);
     }
   }
-  const cache = /* @__PURE__ */ new Map();
-  function listMarkdownPaths() {
-    const found = [];
-    const walk = (absoluteDirectory, relativePrefix) => {
-      let entries;
-      try {
-        entries = readdirSync(absoluteDirectory, { withFileTypes: true });
-      } catch {
+  const deadline = Date.now() + (limits?.maxMs ?? Number.POSITIVE_INFINITY);
+  const found = [];
+  let truncated = false;
+  const isOverLimit = () => limits != null && (found.length >= limits.maxFiles || Date.now() > deadline);
+  const walk = (absoluteDirectory, relativePrefix) => {
+    if (isOverLimit() == true) {
+      truncated = true;
+      return;
+    }
+    let entries;
+    try {
+      entries = readdirSync(absoluteDirectory, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (truncated == true) {
         return;
       }
-      for (const entry of entries) {
-        if (entry.isSymbolicLink() == true) {
-          continue;
-        }
-        const relativePath = relativePrefix + entry.name;
-        if (excludedNames.has(entry.name) == true || excludedPaths.has(relativePath) == true) {
-          continue;
-        }
-        if (entry.isDirectory() == true) {
-          if (entry.name.startsWith(".") == true || entry.name == ALWAYS_EXCLUDED_DIRECTORY) {
-            continue;
-          }
-          walk(join2(absoluteDirectory, entry.name), relativePath + "/");
+      if (entry.isSymbolicLink() == true) {
+        continue;
+      }
+      const relativePath = relativePrefix + entry.name;
+      if (excludedNames.has(entry.name) == true || excludedPaths.has(relativePath) == true) {
+        continue;
+      }
+      if (entry.isDirectory() == true) {
+        if (entry.name.startsWith(".") == true || entry.name == ALWAYS_EXCLUDED_DIRECTORY) {
           continue;
         }
-        if (entry.isFile() == true && /\.md$/i.test(entry.name) == true) {
-          found.push(relativePath);
+        walk(join2(absoluteDirectory, entry.name), relativePath + "/");
+        continue;
+      }
+      if (entry.isFile() == true && /\.md$/i.test(entry.name) == true) {
+        found.push(relativePath);
+        if (isOverLimit() == true) {
+          truncated = true;
+          return;
         }
       }
-    };
-    walk(root, "");
-    return found;
+    }
+  };
+  walk(root, "");
+  return { paths: found, truncated };
+}
+function openLibrary(options) {
+  const root = realpathSync.native(resolve(options.root));
+  if (statSync(root).isDirectory() == false) {
+    throw new Error("root is not a folder: " + root);
   }
+  let name = basename(root);
+  if (name == "") {
+    name = root;
+  }
+  const cache = /* @__PURE__ */ new Map();
   function refresh() {
     const documents = [];
     const seen = /* @__PURE__ */ new Set();
-    for (const path of listMarkdownPaths().sort(compareText)) {
+    for (const path of listMarkdownPaths(root, options.exclude).paths.sort(compareText)) {
       const absolutePath = join2(root, path);
       let modifiedMs;
       let size;
@@ -7885,6 +7906,113 @@ function cutPage(document, start, end, budgetBytes) {
   return { text: joinLines2(lastLine), lastLine };
 }
 
+// src/modules/cli/folder-check.ts
+var LARGEST_FILE_COUNT = 3;
+var COUNT_LIMITS = { maxFiles: COUNT_MAX_FILES, maxMs: COUNT_MAX_MS };
+function isFolder(path) {
+  try {
+    return statSync2(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function comparable(path) {
+  const resolved = resolve2(path);
+  if (process.platform == "win32") {
+    return resolved.toLowerCase();
+  }
+  return resolved;
+}
+function isSameFolder(left, right) {
+  return comparable(left) == comparable(right);
+}
+function isHomeOrDriveRoot(path) {
+  const resolved = resolve2(path);
+  return isSameFolder(resolved, homedir2()) || isSameFolder(resolved, parse(resolved).root);
+}
+function normalizeFolderInput(input2, base = process.cwd()) {
+  let folder = input2.trim();
+  const quoted = /^(["'])(.*)\1$/.exec(folder);
+  if (quoted != null) {
+    folder = quoted[2].trim();
+  }
+  if (folder == "") {
+    return "";
+  }
+  if (folder == "~" || folder.startsWith("~/") || folder.startsWith("~\\")) {
+    folder = homedir2() + folder.slice(1);
+  }
+  return resolve2(base, folder);
+}
+function formatFileCount(files, truncated) {
+  let suffix = "";
+  if (truncated == true) {
+    suffix = "+";
+  }
+  if (files == 1 && truncated == false) {
+    return "1 file";
+  }
+  return `${files}${suffix} files`;
+}
+function countMarkdownFiles(root, exclude) {
+  if (isFolder(root) == false) {
+    return null;
+  }
+  const scan = listMarkdownPaths(root, exclude, COUNT_LIMITS);
+  return { files: scan.paths.length, truncated: scan.truncated };
+}
+function checkFolder(root, exclude) {
+  if (isFolder(root) == false) {
+    return { ok: false, message: `The docs folder does not exist or is not a folder: ${root}` };
+  }
+  const scan = listMarkdownPaths(root, exclude, COUNT_LIMITS);
+  const sized = scan.paths.map((path) => {
+    let bytes = 0;
+    try {
+      bytes = statSync2(join3(root, path)).size;
+    } catch {
+      bytes = 0;
+    }
+    return { path, bytes };
+  });
+  sized.sort((left, right) => right.bytes - left.bytes || compareText(left.path, right.path));
+  return {
+    ok: true,
+    files: sized.length,
+    truncated: scan.truncated,
+    totalBytes: sized.reduce((sum, file2) => sum + file2.bytes, 0),
+    largest: sized.slice(0, LARGEST_FILE_COUNT)
+  };
+}
+function summarizeCheck(check2) {
+  if (check2.ok == false) {
+    return "folder not found";
+  }
+  if (check2.truncated == true) {
+    return formatFileCount(check2.files, true);
+  }
+  return `${formatFileCount(check2.files, false)} \xB7 ${formatSize(check2.totalBytes)}`;
+}
+function describeCheck(check2) {
+  if (check2.ok == false) {
+    return [check2.message];
+  }
+  const lines = [summarizeCheck(check2)];
+  if (check2.truncated == true) {
+    lines.push(`Stopped counting after ${COUNT_MAX_FILES} files or ${COUNT_MAX_MS / 1e3} seconds. Is this the docs folder?`);
+    return lines;
+  }
+  if (check2.files == 0) {
+    lines.push("No .md files found. Check the folder and the Exclude list.");
+    return lines;
+  }
+  lines.push("Largest:");
+  for (const file2 of check2.largest) {
+    lines.push(`  ${file2.path}  ${formatSize(file2.bytes)}`);
+  }
+  return lines;
+}
+
 // src/modules/cli/display.ts
 var STYLE_CODES = {
   dim: "\x1B[2m",
@@ -8022,67 +8150,6 @@ function renderParts(parts, maxWidth, color) {
   return line;
 }
 
-// src/modules/cli/folder-check.ts
-import { statSync as statSync2 } from "node:fs";
-import { homedir as homedir2 } from "node:os";
-import { resolve as resolve2 } from "node:path";
-var LARGEST_FILE_COUNT = 3;
-function isFolder(path) {
-  try {
-    return statSync2(path).isDirectory();
-  } catch {
-    return false;
-  }
-}
-function normalizeFolderInput(input2) {
-  let folder = input2.trim();
-  const quoted = /^(["'])(.*)\1$/.exec(folder);
-  if (quoted != null) {
-    folder = quoted[2].trim();
-  }
-  if (folder == "") {
-    return "";
-  }
-  if (folder == "~" || folder.startsWith("~/") || folder.startsWith("~\\")) {
-    folder = homedir2() + folder.slice(1);
-  }
-  return resolve2(folder);
-}
-function checkFolder(root, exclude) {
-  if (isFolder(root) == false) {
-    return { ok: false, message: `The docs folder does not exist or is not a folder: ${root}` };
-  }
-  const documents = openLibrary({ root, exclude }).refresh();
-  const bySize = [...documents].sort((left, right) => right.totalBytes - left.totalBytes || compareText(left.path, right.path));
-  return {
-    ok: true,
-    files: documents.length,
-    totalBytes: documents.reduce((sum, document) => sum + document.totalBytes, 0),
-    largest: bySize.slice(0, LARGEST_FILE_COUNT).map((document) => ({ path: document.path, bytes: document.totalBytes }))
-  };
-}
-function summarizeCheck(check2) {
-  if (check2.ok == false) {
-    return "folder not found";
-  }
-  return `${pluralize(check2.files, "file")} \xB7 ${formatSize(check2.totalBytes)}`;
-}
-function describeCheck(check2) {
-  if (check2.ok == false) {
-    return [check2.message];
-  }
-  const lines = [summarizeCheck(check2)];
-  if (check2.files == 0) {
-    lines.push("No .md files found. Check the folder and the Exclude list.");
-    return lines;
-  }
-  lines.push("Largest:");
-  for (const file2 of check2.largest) {
-    lines.push(`  ${file2.path}  ${formatSize(file2.bytes)}`);
-  }
-  return lines;
-}
-
 // src/modules/cli/input-owner.ts
 var InputOwner = class {
   constructor(input2) {
@@ -8138,8 +8205,8 @@ var InputOwner = class {
         this.pendingText = "";
         return rest;
       }
-      await new Promise((resolve7) => {
-        this.lineWaiter = resolve7;
+      await new Promise((resolve6) => {
+        this.lineWaiter = resolve6;
         this.input.resume();
       });
       this.lineWaiter = null;
@@ -8304,6 +8371,9 @@ function writeLine(text2 = "") {
 function styled(text2, style) {
   return styleText(text2, style, getTerminal().color);
 }
+function tickMark() {
+  return styleText(symbolsOf(getTerminal()).tick, "green", getTerminal().color);
+}
 function columnsOf(terminal) {
   return terminal.output.columns ?? DEFAULT_COLUMNS;
 }
@@ -8366,7 +8436,7 @@ async function withRawMode(terminal, hideCursor, frame, body) {
   }
 }
 function readKeys(terminal, onKey) {
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve6, reject) => {
     let finished = false;
     const stop = terminal.owner.beginKeys(
       (chunk) => {
@@ -8379,7 +8449,7 @@ function readKeys(terminal, onKey) {
             if (outcome != void 0) {
               finished = true;
               stop();
-              resolve7(outcome.result);
+              resolve6(outcome.result);
               return;
             }
           } catch (error62) {
@@ -8847,6 +8917,122 @@ async function confirm(question, defaultYes, options = {}) {
   return confirmWithLines(terminal, question, defaultYes);
 }
 
+// src/modules/cli/quick-add.ts
+function initialFolderFor(currentFolder) {
+  if (isHomeOrDriveRoot(currentFolder) == true) {
+    return "";
+  }
+  return currentFolder;
+}
+async function addFolderAsEntry(home, root) {
+  const catalog = readCatalog(home);
+  const existing = catalog.entries.find((entry) => isSameFolder(entry.root, root));
+  if (existing != null) {
+    writeLine(`Already added as "${existing.name}".`);
+    return { kind: "exists", name: existing.name };
+  }
+  const check2 = checkFolder(root, []);
+  if (check2.ok == false) {
+    writeLine(styled(check2.message, "red"));
+    return { kind: "declined" };
+  }
+  let summary = formatFileCount(check2.files, check2.truncated).replace(/ files?$/, (unit) => ` markdown${unit}`);
+  if (check2.truncated == false) {
+    summary += ` \xB7 ${formatSize(check2.totalBytes)}`;
+  }
+  writeLine(`  ${summary}`);
+  if (check2.files == 0) {
+    writeLine(styled("No markdown files were found in this folder.", "yellow"));
+  }
+  const name = defaultEntryName(root, catalog.entries.map((entry) => entry.name));
+  const accepted = await confirm(`Add it as "${name}"?`, check2.files > 0, { transient: true });
+  if (accepted == false) {
+    return { kind: "declined" };
+  }
+  const latest = readCatalog(home);
+  const finalName = defaultEntryName(root, latest.entries.map((entry) => entry.name));
+  latest.entries.push({ name: finalName, root, exclude: [], maxBytes: DEFAULT_MAX_BYTES });
+  writeCatalog(home, latest);
+  writeLine(`${tickMark()} Added ${finalName}. Open a new session to use ${finalName}__read and the other tools.`);
+  return { kind: "added", name: finalName };
+}
+async function quickAddFromMenu(home, initialFolder, base) {
+  let candidate = initialFolder;
+  for (; ; ) {
+    let typed;
+    try {
+      typed = await text("Docs folder", { initial: candidate, hint: "the folder that holds your .md files", transient: true });
+    } catch (error62) {
+      if (error62 instanceof PromptBackError) {
+        return { kind: "declined" };
+      }
+      throw error62;
+    }
+    const root = normalizeFolderInput(typed, base);
+    if (root == "") {
+      writeLine(styled("Enter the path of a docs folder.", "red"));
+      candidate = typed;
+      continue;
+    }
+    if (isFolder(root) == false) {
+      writeLine(styled(`The folder does not exist or is not a folder: ${root}`, "red"));
+      candidate = typed;
+      continue;
+    }
+    writeLine(`${tickMark()} Docs folder \xB7 ${root}`);
+    try {
+      return await addFolderAsEntry(home, root);
+    } catch (error62) {
+      if (error62 instanceof PromptBackError) {
+        return { kind: "declined" };
+      }
+      throw error62;
+    }
+  }
+}
+
+// src/modules/cli/add-command.ts
+var EXIT_USAGE = 2;
+async function runAddCommand(options) {
+  let root = normalizeFolderInput(options.cwd, options.cwd);
+  if (options.folder != null) {
+    root = normalizeFolderInput(options.folder, options.cwd);
+  }
+  if (isHomeOrDriveRoot(root) == true) {
+    options.writeError(`"${root}" is your home folder or a drive root, not a docs folder. Run librian add inside a docs folder, or pass its path: librian add <folder>`);
+    return EXIT_USAGE;
+  }
+  if (isFolder(root) == false) {
+    options.writeError(`The folder does not exist or is not a folder: ${root}`);
+    return EXIT_USAGE;
+  }
+  try {
+    writeLine(`Docs folder \xB7 ${root}`);
+    const outcome = await addFolderAsEntry(options.home, root);
+    if (outcome.kind == "declined") {
+      writeLine("Nothing added.");
+    }
+    if (outcome.kind == "added" && readCatalog(options.home).services.length == 0) {
+      writeLine("Run librian and choose Register to use it in Claude Code or Codex.");
+    }
+    return 0;
+  } catch (error62) {
+    if (error62 instanceof PromptClosedError) {
+      return 0;
+    }
+    if (error62 instanceof PromptBackError) {
+      writeLine("Nothing added.");
+      return 0;
+    }
+    let reason = String(error62);
+    if (error62 instanceof Error) {
+      reason = error62.message;
+    }
+    options.writeError(reason);
+    return 1;
+  }
+}
+
 // src/modules/cli/entry-form.ts
 var FORM_ORDER = ["name", "folder", "exclude", "max", "check", "save", "cancel"];
 function snapshotOf(draft) {
@@ -8860,14 +9046,6 @@ function nextRow(current) {
   return FORM_ORDER[Math.min(position + 1, FORM_ORDER.length - 1)];
 }
 function buildRows(draft, home, lastCheck) {
-  let nameDetail = draft.name;
-  if (nameDetail == "") {
-    nameDetail = "(from the folder)";
-  }
-  let nameHint = "";
-  if (draft.nameTouched == false) {
-    nameHint = "follows the folder until you change it";
-  }
   let folderDetail = draft.root;
   let folderKind = "path";
   let folderHint = "";
@@ -8886,7 +9064,7 @@ function buildRows(draft, home, lastCheck) {
     checkDetail = lastCheck.summary;
   }
   return [
-    { value: "name", key: "name", label: "Name", detail: nameDetail, hint: nameHint },
+    { value: "name", key: "name", label: "Name", detail: draft.name, hint: "prefixes the tool names" },
     { value: "folder", key: "folder", label: "Docs folder", detail: folderDetail, detailKind: folderKind, hint: folderHint },
     { value: "exclude", key: "exclude", label: "Exclude", detail: excludeDetail, hint: "folder names or paths to skip" },
     { value: "max", key: "max", label: "Max bytes", detail: String(draft.maxBytes), hint: "response size limit" },
@@ -8899,33 +9077,24 @@ function buildRows(draft, home, lastCheck) {
 async function openEntryForm(home, editing) {
   const catalog = readCatalog(home);
   const existing = catalog.entries.find((entry) => entry.name == editing);
-  const otherNames = () => readCatalog(home).entries.filter((entry) => entry.name != editing).map((entry) => entry.name);
-  let draft = { name: "", nameTouched: false, root: "", exclude: [], maxBytes: DEFAULT_MAX_BYTES };
-  let cursor = "folder";
-  if (existing != null) {
-    draft = { name: existing.name, nameTouched: true, root: existing.root, exclude: [...existing.exclude], maxBytes: existing.maxBytes };
-    cursor = "name";
+  if (existing == null) {
+    writeLine(styled(`There is no docs folder named "${editing}" any more.`, "red"));
+    return "cancelled";
   }
+  const otherNames = () => readCatalog(home).entries.filter((entry) => entry.name != editing).map((entry) => entry.name);
+  let draft = { name: existing.name, root: existing.root, exclude: [...existing.exclude], maxBytes: existing.maxBytes };
+  let cursor = "name";
   const openingSnapshot = snapshotOf(draft);
   let lastCheck = null;
-  let verifiedKey = null;
-  if (existing != null) {
-    verifiedKey = checkKeyOf(draft);
-  }
-  let title = "Add docs folder";
-  if (existing != null) {
-    title = `Edit "${existing.name}"`;
-  }
+  let verifiedKey = checkKeyOf(draft);
+  const title = `Edit "${existing.name}"`;
   const askName = async () => {
     let candidate = draft.name;
     for (; ; ) {
       const typed = (await text("Name", { initial: candidate, hint: "lowercase letters, digits and _, up to 24", transient: true })).trim();
       const problem = checkEntryName(typed, otherNames());
       if (problem == null) {
-        if (typed != draft.name) {
-          draft.name = typed;
-          draft.nameTouched = true;
-        }
+        draft.name = typed;
         return;
       }
       writeLine(styled(problem, "red"));
@@ -8935,12 +9104,6 @@ async function openEntryForm(home, editing) {
   const askFolder = async () => {
     const typed = await text("Docs folder", { initial: draft.root, hint: "the folder that holds your .md files", transient: true });
     draft.root = normalizeFolderInput(typed);
-    if (draft.nameTouched == false) {
-      draft.name = "";
-      if (draft.root != "") {
-        draft.name = defaultEntryName(draft.root, otherNames());
-      }
-    }
   };
   const askExclude = async () => {
     const typed = await text("Exclude", { initial: draft.exclude.join(", "), hint: "comma separated, empty for none", transient: true });
@@ -9004,7 +9167,7 @@ async function openEntryForm(home, editing) {
     const entry = { name: draft.name, root: draft.root, exclude: draft.exclude, maxBytes: draft.maxBytes };
     try {
       const latest = readCatalog(home);
-      const position = latest.entries.findIndex((item) => item.name == editing);
+      const position = latest.entries.findIndex((item) => item.name == existing.name);
       if (position >= 0) {
         latest.entries[position] = entry;
       } else {
@@ -9098,21 +9261,6 @@ var SERVICE_NAMES = { claude: "Claude Code", codex: "Codex" };
 var ITEM_PREFIX = "item:";
 var ENTRY_PATH_WIDTH = 50;
 var HOME_PATH_WIDTH = 40;
-var LibraryCache = class {
-  libraries = /* @__PURE__ */ new Map();
-  countFiles(entry) {
-    if (isFolder(entry.root) == false) {
-      return null;
-    }
-    const key = JSON.stringify([entry.root, entry.exclude]);
-    let library = this.libraries.get(key);
-    if (library == null) {
-      library = openLibrary({ root: entry.root, exclude: entry.exclude });
-      this.libraries.set(key, library);
-    }
-    return library.refresh().length;
-  }
-};
 function describeServices(catalog) {
   if (catalog.services.length == 0) {
     return "none registered";
@@ -9133,13 +9281,13 @@ function describeRuntime(home, context) {
     return "status unknown";
   }
 }
-function buildMainRows(home, context, catalog, cache) {
+function buildMainRows(home, context, catalog) {
   const rows = [];
   for (const entry of catalog.entries) {
-    const files = cache.countFiles(entry);
+    const counted = countMarkdownFiles(entry.root, entry.exclude);
     let hint = "folder not found";
-    if (files != null) {
-      hint = pluralize(files, "file");
+    if (counted != null) {
+      hint = formatFileCount(counted.files, counted.truncated);
     }
     rows.push({ value: ITEM_PREFIX + entry.name, label: entry.name, detail: entry.root, detailKind: "path", hint });
   }
@@ -9147,7 +9295,7 @@ function buildMainRows(home, context, catalog, cache) {
     rows.push("separator");
   }
   rows.push({ value: "add", key: "add", label: "Add docs folder" });
-  rows.push({ value: "services", key: "services", label: "AI services", hint: describeServices(catalog) });
+  rows.push({ value: "services", key: "services", label: "Register", hint: describeServices(catalog) });
   rows.push({ value: "runtime", key: "runtime", label: "Runtime", hint: describeRuntime(home, context) });
   rows.push({ value: "quit", key: "quit", label: "Quit" });
   return rows;
@@ -9225,7 +9373,6 @@ async function runScreen(open2) {
   }
 }
 async function runMainMenu(home, context) {
-  const cache = new LibraryCache();
   let cursor;
   for (; ; ) {
     let catalog;
@@ -9241,7 +9388,7 @@ async function runMainMenu(home, context) {
     }
     let choice;
     try {
-      choice = await select(`librian ${context.version} \xB7 ${shortenPath(home, HOME_PATH_WIDTH)}`, buildMainRows(home, context, catalog, cache), { initial: cursor, transient: true });
+      choice = await select(`librian ${context.version} \xB7 ${shortenPath(home, HOME_PATH_WIDTH)}`, buildMainRows(home, context, catalog), { initial: cursor, transient: true });
     } catch (error62) {
       if (error62 instanceof PromptBackError) {
         return 0;
@@ -9253,11 +9400,9 @@ async function runMainMenu(home, context) {
       return 0;
     }
     if (choice == "add") {
-      if (await openEntryForm(home, null) == "saved") {
-        const newest = readCatalog(home).entries.at(-1);
-        if (newest != null) {
-          cursor = ITEM_PREFIX + newest.name;
-        }
+      const outcome = await quickAddFromMenu(home, initialFolderFor(context.cwd ?? process.cwd()), context.cwd ?? process.cwd());
+      if (outcome.kind != "declined") {
+        cursor = ITEM_PREFIX + outcome.name;
       }
     } else if (choice == "services") {
       await runScreen(() => context.openServicesScreen(home));
@@ -9281,7 +9426,8 @@ async function openMainMenu(home, context) {
 
 // src/modules/mcp/arguments.ts
 var USAGE = [
-  "Usage: librian                       Open the menu (docs folders, AI services, runtime)",
+  "Usage: librian                       Open the menu (docs folders, register, runtime)",
+  "       librian add [<folder>]        Add a folder (default: the current folder) as a docs folder, without the menu",
   "       librian serve --catalog       Serve every docs folder of the catalog (what AI services run)",
   "       librian serve --root <folder> [--exclude <name>]... [--max-bytes <n>]",
   "                                     Serve one folder with unprefixed tools",
@@ -9289,7 +9435,7 @@ var USAGE = [
   "",
   "  --catalog          Read the docs folders from <LIBRIAN_HOME>/catalog.json (default ~/.librian)",
   "  --root <folder>    Markdown docs folder to serve",
-  "  --exclude <name>   Skip a folder name (e.g. evidence) or a root-relative path (e.g. ks/archive); repeatable",
+  "  --exclude <name>   Skip a folder name (e.g. evidence) or a root-relative path (e.g. guide/archive); repeatable",
   `  --max-bytes <n>    Response size limit in UTF-8 bytes (default ${DEFAULT_MAX_BYTES}, minimum ${MIN_MAX_BYTES})`,
   "  --help             Show this help",
   "  --version          Show the version"
@@ -9357,6 +9503,28 @@ function parseServe(argv) {
   }
   return { kind: "serve-root", root, exclude, maxBytes: maxBytes ?? DEFAULT_MAX_BYTES };
 }
+function parseAdd(argv) {
+  let folder = null;
+  for (const token of argv) {
+    if (token == "--help") {
+      return { kind: "help" };
+    }
+    if (token == "--version") {
+      return { kind: "version" };
+    }
+    if (token.startsWith("-") == true) {
+      return { kind: "error", message: `Unknown argument "${token}".` };
+    }
+    if (token == "") {
+      return { kind: "error", message: "The folder must not be empty." };
+    }
+    if (folder != null) {
+      return { kind: "error", message: "librian add takes one folder." };
+    }
+    folder = token;
+  }
+  return { kind: "add", folder };
+}
 function parseArguments(argv) {
   if (argv.length == 0) {
     return { kind: "menu" };
@@ -9368,6 +9536,9 @@ function parseArguments(argv) {
   if (command == "--version") {
     return { kind: "version" };
   }
+  if (command == "add") {
+    return parseAdd(argv.slice(1));
+  }
   if (command == "serve") {
     return parseServe(argv.slice(1));
   }
@@ -13562,7 +13733,7 @@ __export(core_exports2, {
   memoizer: () => memoizer,
   mergeValues: () => mergeValues2,
   meta: () => meta,
-  parse: () => parse,
+  parse: () => parse2,
   parseAsync: () => parseAsync,
   parseURLObject: () => parseURLObject,
   prettifyError: () => prettifyError,
@@ -14782,7 +14953,7 @@ var _parse = (_Err) => {
   };
   return fn;
 };
-var parse = /* @__PURE__ */ _parse($ZodRealError);
+var parse2 = /* @__PURE__ */ _parse($ZodRealError);
 var _parseAsync = (_Err) => {
   const fn = async (schema, value, _ctx, params) => {
     const ctx = _ctx ? { ..._ctx, async: true } : { async: true };
@@ -14870,18 +15041,18 @@ var validateAsync = async (schema, value, _ctx) => {
   return result.issues.length === 0;
 };
 var _encode = (_Err) => {
-  const parse3 = _parse(_Err);
+  const parse4 = _parse(_Err);
   const fn = (schema, value, _ctx, _params) => {
     const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
-    return parse3(schema, value, ctx, finalizeParams(fn, _params));
+    return parse4(schema, value, ctx, finalizeParams(fn, _params));
   };
   return fn;
 };
 var encode = /* @__PURE__ */ _encode($ZodRealError);
 var _decode = (_Err) => {
-  const parse3 = _parse(_Err);
+  const parse4 = _parse(_Err);
   const fn = (schema, value, _ctx, _params) => {
-    return parse3(schema, value, _ctx, finalizeParams(fn, _params));
+    return parse4(schema, value, _ctx, finalizeParams(fn, _params));
   };
   return fn;
 };
@@ -16376,7 +16547,7 @@ function capSize(inst, size) {
   if (!caps.length)
     return;
   const cap = Math.min(...caps.map((c) => c[0]));
-  const parse3 = inst._zod.parse;
+  const parse4 = inst._zod.parse;
   inst._zod.parse = (payload, ctx) => {
     const n = size(payload.value);
     if (n > cap && !ctx?.skipChecks && ctx?.direction !== "backward") {
@@ -16390,7 +16561,7 @@ function capSize(inst, size) {
         }
       }
     }
-    return parse3(payload, ctx);
+    return parse4(payload, ctx);
   };
 }
 var arraySize = (input2) => Array.isArray(input2) ? input2.length : -1;
@@ -17935,10 +18106,10 @@ var $ZodFunction = /* @__PURE__ */ $constructor("$ZodFunction", (inst, def) => {
       throw new Error("implement() must be called with a function");
     }
     return Object.defineProperty(function(...args) {
-      const parsedArgs = inst._def.input ? parse(inst._def.input, args) : args;
+      const parsedArgs = inst._def.input ? parse2(inst._def.input, args) : args;
       const result = Reflect.apply(func, this, parsedArgs);
       if (inst._def.output) {
-        return parse(inst._def.output, result);
+        return parse2(inst._def.output, result);
       }
       return result;
     }, "_zod", { value: inst._zod, enumerable: false });
@@ -18079,7 +18250,7 @@ var recursive = /* @__PURE__ */ new WeakMap();
 var NONE = 0;
 var ASSUMED = 1;
 var PROVEN = 2;
-function isRecursive(inst, stack, resolve7) {
+function isRecursive(inst, stack, resolve6) {
   const cached2 = recursive.get(inst);
   if (cached2 !== void 0)
     return cached2 ? PROVEN : NONE;
@@ -18089,7 +18260,7 @@ function isRecursive(inst, stack, resolve7) {
   let result = NONE;
   const check2 = (child) => {
     if (result !== PROVEN && child?._zod) {
-      const answer = isRecursive(child, stack, resolve7);
+      const answer = isRecursive(child, stack, resolve6);
       if (answer > result)
         result = answer;
     }
@@ -18100,7 +18271,7 @@ function isRecursive(inst, stack, resolve7) {
       const desc = Object.getOwnPropertyDescriptor(sh, key);
       if (spread && !desc.enumerable)
         continue;
-      const child = desc.get ? ASSUMED : desc.value?._zod ? isRecursive(desc.value, stack, resolve7) : NONE;
+      const child = desc.get ? ASSUMED : desc.value?._zod ? isRecursive(desc.value, stack, resolve6) : NONE;
       if (child > answer)
         answer = child;
     }
@@ -18164,7 +18335,7 @@ function isRecursive(inst, stack, resolve7) {
       break;
     // `$ZodLazy` caches its inner on the def, so a resolved edge is followed exactly
     case "lazy": {
-      const inner = def._cachedInner ?? (resolve7 ? inst._zod.innerType : void 0);
+      const inner = def._cachedInner ?? (resolve6 ? inst._zod.innerType : void 0);
       merge2(inner ? isRecursive(inner, stack, false) : ASSUMED);
       break;
     }
@@ -29998,7 +30169,7 @@ var ZodMiniType = /* @__PURE__ */ $constructor("ZodMiniType", (inst, def) => {
     own(this, "with", value);
   },
   parse(data, params) {
-    return parse(this, data, params, { callee: this.parse });
+    return parse2(this, data, params, { callee: this.parse });
   },
   parseAsync(data, params) {
     return parseAsync(this, data, params, { callee: this.parseAsync });
@@ -30561,7 +30732,7 @@ __export(external_exports, {
   optional: () => optional,
   output: () => output,
   overwrite: () => _overwrite,
-  parse: () => parse2,
+  parse: () => parse3,
   parseAsync: () => parseAsync2,
   partialRecord: () => partialRecord,
   pipe: () => pipe,
@@ -30889,7 +31060,7 @@ var ZodRealError = /* @__PURE__ */ $constructor("ZodError", initializer2, void 0
 });
 
 // node_modules/zod/v4/classic/parse.js
-var parse2 = /* @__PURE__ */ _parse(ZodRealError);
+var parse3 = /* @__PURE__ */ _parse(ZodRealError);
 var parseAsync2 = /* @__PURE__ */ _parseAsync(ZodRealError);
 var safeParse3 = /* @__PURE__ */ _safeParse(ZodRealError);
 var safeParseAsync3 = /* @__PURE__ */ _safeParseAsync(ZodRealError);
@@ -31026,7 +31197,7 @@ var ZodType2 = /* @__PURE__ */ $constructor("ZodType", (inst, def) => {
     util_exports.own(this, "~standard", value);
   },
   parse: function _parse2(data, params) {
-    return parse2(this, data, params, { callee: _parse2 });
+    return parse3(this, data, params, { callee: _parse2 });
   },
   parseAsync: async function _parseAsync2(data, params) {
     return await parseAsync2(this, data, params, { callee: _parseAsync2 });
@@ -36602,7 +36773,7 @@ var Protocol = class {
           return;
         }
         const pollInterval = task2.pollInterval ?? this._options?.defaultTaskPollInterval ?? 1e3;
-        await new Promise((resolve7) => setTimeout(resolve7, pollInterval));
+        await new Promise((resolve6) => setTimeout(resolve6, pollInterval));
         options?.signal?.throwIfAborted();
       }
     } catch (error62) {
@@ -36619,7 +36790,7 @@ var Protocol = class {
    */
   request(request, resultSchema, options) {
     const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options ?? {};
-    return new Promise((resolve7, reject) => {
+    return new Promise((resolve6, reject) => {
       const earlyReject = (error62) => {
         reject(error62);
       };
@@ -36697,7 +36868,7 @@ var Protocol = class {
           if (!parseResult.success) {
             reject(parseResult.error);
           } else {
-            resolve7(parseResult.data);
+            resolve6(parseResult.data);
           }
         } catch (error62) {
           reject(error62);
@@ -36959,12 +37130,12 @@ var Protocol = class {
       }
     } catch {
     }
-    return new Promise((resolve7, reject) => {
+    return new Promise((resolve6, reject) => {
       if (signal.aborted) {
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
         return;
       }
-      const timeoutId = setTimeout(resolve7, interval);
+      const timeoutId = setTimeout(resolve6, interval);
       signal.addEventListener("abort", () => {
         clearTimeout(timeoutId);
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
@@ -38104,7 +38275,7 @@ var McpServer = class {
     let task = createTaskResult.task;
     const pollInterval = task.pollInterval ?? 5e3;
     while (task.status !== "completed" && task.status !== "failed" && task.status !== "cancelled") {
-      await new Promise((resolve7) => setTimeout(resolve7, pollInterval));
+      await new Promise((resolve6) => setTimeout(resolve6, pollInterval));
       const updatedTask = await extra.taskStore.getTask(taskId);
       if (!updatedTask) {
         throw new McpError(ErrorCode.InternalError, `Task ${taskId} not found during polling`);
@@ -38768,12 +38939,12 @@ var StdioServerTransport = class {
     this.onclose?.();
   }
   send(message) {
-    return new Promise((resolve7) => {
+    return new Promise((resolve6) => {
       const json2 = serializeMessage(message);
       if (this._stdout.write(json2)) {
-        resolve7();
+        resolve6();
       } else {
-        this._stdout.once("drain", resolve7);
+        this._stdout.once("drain", resolve6);
       }
     });
   }
@@ -38873,7 +39044,7 @@ function normalizePrefix(prefix) {
 }
 function runList(library, args, maxBytes) {
   if (args.prefix != null && typeof args.prefix != "string") {
-    return errorResult('prefix must be a string: the start of a path such as "ks/ci".');
+    return errorResult('prefix must be a string: the start of a path such as "guide/api".');
   }
   let prefix = "";
   if (typeof args.prefix == "string") {
@@ -39337,6 +39508,8 @@ var ELLIPSIS2 = "\u2026";
 var ELLIPSIS_BYTES = Buffer.byteLength(ELLIPSIS2);
 var QUERY_ECHO_MAX_CHARS = 80;
 var WORD_CHARACTERS = /[a-z0-9_]/;
+var BM25_K1 = 1.2;
+var BM25_B = 0.75;
 function normalize(text2) {
   return text2.normalize("NFC").toLowerCase();
 }
@@ -39434,14 +39607,18 @@ function matchBlock(document, start, end, chainText, label, bodyStart, terms) {
     }
     hits += counts[termIndex];
   }
-  return { document, start, end, label, bytes: document.bytesOf(start, end), hits, titleHits, bodyStart };
+  return { document, start, end, label, bytes: document.bytesOf(start, end), termCounts: counts, hits, titleHits, score: 0, bodyStart };
 }
 function collectMatches(documents, terms) {
   const matches = [];
+  let scannedBytes = 0;
+  let scannedBlocks = 0;
   for (const document of documents) {
     const headings = document.headings;
     const introEnd = headings.length == 0 ? document.lines.length : headings[0].line - 1;
     if (introEnd >= 1 && isBlank(document, 1, introEnd) == false) {
+      scannedBytes += document.bytesOf(1, introEnd);
+      scannedBlocks += 1;
       const introMatch = matchBlock(document, 1, introEnd, "", INTRO_TITLE, 1, terms);
       if (introMatch != null) {
         matches.push(introMatch);
@@ -39449,6 +39626,8 @@ function collectMatches(documents, terms) {
     }
     for (let index = 0; index < headings.length; index += 1) {
       const heading = headings[index];
+      scannedBytes += document.bytesOf(heading.line, heading.blockEnd);
+      scannedBlocks += 1;
       const chainText = chainIndices(document, index).map((position) => document.headings[position].title).join("\n");
       const label = headingChain(document, index);
       const match = matchBlock(document, heading.line, heading.blockEnd, chainText, label, heading.line + 1, terms);
@@ -39457,14 +39636,22 @@ function collectMatches(documents, terms) {
       }
     }
   }
-  return matches;
+  return { matches, averageBytes: scannedBlocks == 0 ? 1 : scannedBytes / scannedBlocks };
+}
+function scoreMatch(match, averageBytes) {
+  const lengthFactor = 1 - BM25_B + BM25_B * (match.bytes / averageBytes);
+  let score = 0;
+  for (const termCount of match.termCounts) {
+    score += termCount * (BM25_K1 + 1) / (termCount + BM25_K1 * lengthFactor);
+  }
+  return score;
 }
 function compareMatches(left, right) {
   if (left.titleHits != right.titleHits) {
     return right.titleHits - left.titleHits;
   }
-  if (left.hits != right.hits) {
-    return right.hits - left.hits;
+  if (left.score != right.score) {
+    return right.score - left.score;
   }
   const byPath = compareText(left.document.path, right.document.path);
   if (byPath != 0) {
@@ -39554,7 +39741,10 @@ function runSearch(library, args, maxBytes) {
     return errorResult("Query is empty. Give one or more words; wrap a phrase in double quotes.");
   }
   const documents = library.refresh().filter((document) => document.path.startsWith(prefix));
-  const matches = collectMatches(documents, terms);
+  const { matches, averageBytes } = collectMatches(documents, terms);
+  for (const match of matches) {
+    match.score = scoreMatch(match, averageBytes);
+  }
   matches.sort(compareMatches);
   const fileCount = new Set(matches.map((match) => match.document.path)).size;
   const echo = JSON.stringify(truncateChars(query.trim(), QUERY_ECHO_MAX_CHARS));
@@ -39630,9 +39820,9 @@ function describeTools(folder) {
   return [
     {
       name: nameOf("list"),
-      description: `${tag}List the markdown files under ${where} with size and document title, grouped by folder. Use prefix to open one folder: \`ks/ci\` matches \`ks/ci/\u2026\` and \`ks/ci-web-renewal.md\`, \`ks/ci/\` matches the folder only.`,
+      description: `${tag}List the markdown files under ${where} with size and document title, grouped by folder. Use prefix to open one folder: \`guide/api\` matches \`guide/api/\u2026\` and \`guide/api-notes.md\`, \`guide/api/\` matches the folder only.`,
       inputSchema: {
-        prefix: external_exports.string().optional().describe("Root-relative path prefix, e.g. `ks/ci/`. Omit to list everything.")
+        prefix: external_exports.string().optional().describe("Root-relative path prefix, e.g. `guide/api/`. Omit to list everything.")
       },
       runner: runList
     },
@@ -39807,12 +39997,12 @@ function catalogReadyLine(version2, home, catalog, opened) {
 
 // src/modules/setup/runtime.ts
 import { existsSync as existsSync2, lstatSync, mkdirSync as mkdirSync2, readFileSync as readFileSync3, realpathSync as realpathSync3, rmSync as rmSync2 } from "node:fs";
-import { dirname, join as join4, resolve as resolve4 } from "node:path";
+import { dirname, join as join5, resolve as resolve4 } from "node:path";
 
 // src/modules/setup/commands.ts
 import { spawn } from "node:child_process";
 import { accessSync, constants, statSync as statSync4 } from "node:fs";
-import { delimiter, join as join3 } from "node:path";
+import { delimiter, join as join4 } from "node:path";
 var DEFAULT_TIMEOUT_MS = 3e4;
 var WINDOWS_SCRIPT_PATTERN = /\.(cmd|bat)$/i;
 function quotePart(part) {
@@ -39841,7 +40031,7 @@ function findOnPath(name, env = process.env, platform = process.platform) {
   }
   for (const directory of directories) {
     for (const candidate of candidates) {
-      const path = join3(directory, candidate);
+      const path = join4(directory, candidate);
       try {
         if (statSync4(path).isFile() == false) {
           continue;
@@ -39950,17 +40140,17 @@ var PACKAGE_NAME = "librian";
 var INSTALL_TIMEOUT_MS = 18e4;
 var VIEW_TIMEOUT_MS = 3e4;
 function runtimeDirectory(home) {
-  return join4(home, "runtime");
+  return join5(home, "runtime");
 }
 function packageDirectory(home) {
-  return join4(runtimeDirectory(home), "node_modules", PACKAGE_NAME);
+  return join5(runtimeDirectory(home), "node_modules", PACKAGE_NAME);
 }
 function runtimeCliPath(home) {
-  return join4(packageDirectory(home), "dist", "cli.js");
+  return join5(packageDirectory(home), "dist", "cli.js");
 }
 function readPackageVersion(directory) {
   try {
-    const parsed = JSON.parse(readFileSync3(join4(directory, "package.json"), "utf8"));
+    const parsed = JSON.parse(readFileSync3(join5(directory, "package.json"), "utf8"));
     return typeof parsed.version == "string" ? parsed.version : null;
   } catch {
     return null;
@@ -39992,8 +40182,8 @@ function compareVersions(left, right) {
 function findNpmCli(nodePath) {
   const nodeDirectory = dirname(nodePath);
   const candidates = [
-    join4(nodeDirectory, "node_modules", "npm", "bin", "npm-cli.js"),
-    join4(nodeDirectory, "..", "lib", "node_modules", "npm", "bin", "npm-cli.js")
+    join5(nodeDirectory, "node_modules", "npm", "bin", "npm-cli.js"),
+    join5(nodeDirectory, "..", "lib", "node_modules", "npm", "bin", "npm-cli.js")
   ];
   for (const candidate of candidates) {
     if (existsSync2(candidate) == true) {
@@ -40039,24 +40229,6 @@ async function installRuntime(home, spec, toolchain) {
   }
   return { ok: true, message: status.state == "linked" ? `linked to ${status.linkedFrom}` : `${status.version ?? "?"} installed` };
 }
-function checkCheckout(path) {
-  if (existsSync2(path) == false) {
-    return `${path} does not exist.`;
-  }
-  let name;
-  try {
-    name = JSON.parse(readFileSync3(join4(path, "package.json"), "utf8")).name;
-  } catch {
-    return `${path} has no readable package.json.`;
-  }
-  if (name != PACKAGE_NAME) {
-    return `${path} is not the ${PACKAGE_NAME} package.`;
-  }
-  if (existsSync2(join4(path, "dist", "cli.js")) == false) {
-    return `${path} has no dist/cli.js; run \`npm run build\` there first.`;
-  }
-  return null;
-}
 async function latestPublishedVersion(toolchain) {
   const viewed = await runNpm(toolchain, ["view", PACKAGE_NAME, "version"], VIEW_TIMEOUT_MS);
   if (viewed.ok == false) {
@@ -40076,12 +40248,9 @@ function uninstallRuntime(home) {
   rmSync2(directory, { recursive: true, force: true });
 }
 
-// src/modules/setup/runtime-screen.ts
-import { resolve as resolve5 } from "node:path";
-
 // src/modules/setup/services.ts
 import { homedir as homedir3 } from "node:os";
-import { join as join5 } from "node:path";
+import { join as join6 } from "node:path";
 
 // src/modules/setup/probe.ts
 import { spawn as spawn2 } from "node:child_process";
@@ -40188,7 +40357,7 @@ function defaultServiceDependencies() {
   return { ...defaultToolchain(), probe: probeServer };
 }
 function isDefaultHome(home) {
-  return normalizeForCompare(home) == normalizeForCompare(join5(homedir3(), ".librian"));
+  return normalizeForCompare(home) == normalizeForCompare(join6(homedir3(), ".librian"));
 }
 function expectedRegistration(home, toolchain) {
   const environment = {};
@@ -40403,7 +40572,6 @@ function buildRows2(status, latest, checked) {
       rows.push({ value: "check", key: "check", label: "Check for updates", hint: checked == true ? "up to date" : void 0 });
     }
   }
-  rows.push({ value: "link", key: "link", label: "Use a local checkout", hint: "link a built librian folder" });
   if (status.state != "missing") {
     rows.push({ value: "uninstall", key: "uninstall", label: "Uninstall" });
   }
@@ -40497,25 +40665,6 @@ async function openRuntimeScreen(home, dependencies = defaultServiceDependencies
       checked = false;
       latest = null;
       await checkRegisteredServer(home, dependencies);
-    } else if (choice == "link") {
-      let answer;
-      try {
-        answer = await text("Folder of the built librian checkout", { initial: status.linkedFrom, transient: true });
-      } catch (error62) {
-        if (error62 instanceof PromptBackError == false) {
-          throw error62;
-        }
-        continue;
-      }
-      const checkout = resolve5(answer.trim().replace(/^"(.*)"$/, "$1"));
-      const problem = checkCheckout(checkout);
-      if (problem != null) {
-        writeLine(styled(problem, "red"));
-        continue;
-      }
-      writeLine(styled("Linking the checkout\u2026", "dim"));
-      printResult(await installRuntime(home, checkout, dependencies), "link");
-      await checkRegisteredServer(home, dependencies);
     } else if (choice == "uninstall") {
       await uninstall(home, dependencies);
     }
@@ -40592,7 +40741,7 @@ async function openServicesScreen(home, dependencies = defaultServiceDependencie
     const needsRuntime = runtimeStatus(home).state == "missing";
     const registersSomething = planServiceChanges(statuses, wanted, home, dependencies).some((change) => change.action == "register");
     const blockedApply = needsRuntime == true && registersSomething == true ? "install the runtime first" : null;
-    const choice = await select("AI services", buildRows3(statuses, wanted, blockedApply), { initial: cursor, transient: true });
+    const choice = await select("Register", buildRows3(statuses, wanted, blockedApply), { initial: cursor, transient: true });
     cursor = choice;
     if (choice == "back") {
       return;
@@ -40641,7 +40790,7 @@ async function openServicesScreen(home, dependencies = defaultServiceDependencie
 }
 
 // src/cli.ts
-var EXIT_USAGE = 2;
+var EXIT_USAGE2 = 2;
 async function main() {
   const parsed = parseArguments(process.argv.slice(2));
   if (parsed.kind == "help") {
@@ -40657,7 +40806,16 @@ async function main() {
   if (parsed.kind == "error") {
     writeStderrLine(`librian: ${parsed.message}`);
     writeStderrLine(USAGE);
-    process.exitCode = EXIT_USAGE;
+    process.exitCode = EXIT_USAGE2;
+    return;
+  }
+  if (parsed.kind == "add") {
+    process.exitCode = await runAddCommand({
+      home: librianHome(),
+      folder: parsed.folder,
+      cwd: process.cwd(),
+      writeError: (line) => writeStderrLine(`librian: ${line}`)
+    });
     return;
   }
   if (parsed.kind == "menu") {
@@ -40693,7 +40851,7 @@ async function main() {
     writeStderrLine(catalogReadyLine(package_default.version, home, catalog, opened));
     return;
   }
-  const root = resolve6(parsed.root);
+  const root = resolve5(parsed.root);
   let isFolder3 = false;
   try {
     isFolder3 = statSync5(root).isDirectory();
@@ -40702,7 +40860,7 @@ async function main() {
   }
   if (isFolder3 == false) {
     writeStderrLine(`librian: root "${root}" does not exist or is not a folder.`);
-    process.exitCode = EXIT_USAGE;
+    process.exitCode = EXIT_USAGE2;
     return;
   }
   const library = openLibrary({ root, exclude: parsed.exclude });