veefore 1.5.0 → 1.6.1

package/dist/veefore.mjs

@@ -1030,6 +1030,97 @@ async function select(question, real, settings = {}) {
     draw();
   });
 }
+async function selectMany(question, options, settings = {}) {
+  if (options.length === 0) return [];
+  const ticked = options.map((option) => settings.selected?.(option) ?? true);
+  if (!isInteractive()) return options.filter((_, index) => ticked[index]).map((o) => o.value);
+  flushCapture();
+  let cursor = 0;
+  let rendered = 0;
+  const stdin = process.stdin;
+  const stdout = process.stdout;
+  const labelWidth = Math.max(...options.map((option) => [...option.label].length));
+  const draw = () => {
+    const width = columns();
+    const count = ticked.filter(Boolean).length;
+    const lines = [];
+    lines.push(
+      `${brand("?")} ${style.bold(question)} ${style.grey(`(${count}/${options.length})`)}`
+    );
+    if (settings.help) lines.push(`  ${style.grey(settings.help)}`);
+    const room = Math.max(3, (process.stdout.rows || 24) - lines.length - 3);
+    const window = Math.min(options.length, room);
+    let first = Math.max(0, Math.min(cursor - (window >> 1), options.length - window));
+    if (window === options.length) first = 0;
+    if (first > 0) lines.push(style.grey(`    \u2191 ${first} more`));
+    for (let index = first; index < first + window; index += 1) {
+      const option = options[index];
+      const active = index === cursor;
+      const pointer = active ? brand("\u276F") : " ";
+      const box = ticked[index] ? style.green("\u25C9") : style.grey("\u25EF");
+      const text = option.hint ? option.label.padEnd(labelWidth) : option.label;
+      const hint = option.hint ? `  ${style.grey(option.hint)}` : "";
+      const label = active ? brand(text) : ticked[index] ? text : style.grey(text);
+      lines.push(fit(`${pointer} ${box} ${label}${hint}`, width - 1));
+    }
+    const rest = options.length - (first + window);
+    if (rest > 0) lines.push(style.grey(`    \u2193 ${rest} more`));
+    lines.push(style.grey("  \u2191\u2193 move \xB7 space toggle \xB7 a all/none \xB7 enter confirm \xB7 esc cancel"));
+    if (rendered > 0) stdout.write(`\x1B[${rendered}A\r\x1B[J`);
+    stdout.write(`${lines.join("\n")}
+`);
+    rendered = lines.length;
+  };
+  return new Promise((resolve, reject) => {
+    const wasRaw = stdin.isRaw;
+    const restoreCursor = () => {
+      if (!inApp()) stdout.write("\x1B[?25h");
+    };
+    const onResize = () => draw();
+    const finish = (confirmed) => {
+      stdin.off("keypress", onKey);
+      stdin.setRawMode(wasRaw);
+      stdin.pause();
+      process.stdout.off("resize", onResize);
+      process.off("exit", restoreCursor);
+      if (rendered > 0) stdout.write(`\x1B[${rendered}A\r\x1B[J`);
+      restoreCursor();
+      if (!confirmed) {
+        stdout.write(`${style.grey("\u2717")} ${question} ${style.grey("cancelled")}
+`);
+        reject(new MenuCancelled());
+        return;
+      }
+      const chosen = options.filter((_, index) => ticked[index]);
+      const summary = chosen.length === options.length ? `all ${options.length}` : chosen.length === 0 ? "none" : `${chosen.length} of ${options.length}`;
+      stdout.write(`${style.green("\u2713")} ${question} ${brand(summary)}
+`);
+      resolve(chosen.map((option) => option.value));
+    };
+    const onKey = (input, key = {}) => {
+      if (key.ctrl && key.name === "c" || key.name === "escape") return finish(false);
+      if (key.name === "return" || key.name === "enter") return finish(true);
+      if (key.name === "space") ticked[cursor] = !ticked[cursor];
+      else if (input === "a" || input === "A") {
+        const all = ticked.every(Boolean);
+        ticked.fill(!all);
+      } else if (key.name === "up" || key.name === "k") {
+        cursor = (cursor - 1 + options.length) % options.length;
+      } else if (key.name === "down" || key.name === "j" || key.name === "tab") {
+        cursor = (cursor + 1) % options.length;
+      } else return;
+      draw();
+    };
+    process.once("exit", restoreCursor);
+    emitKeypressEvents(stdin);
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdout.write("\x1B[?25l");
+    stdin.on("keypress", onKey);
+    process.stdout.on("resize", onResize);
+    draw();
+  });
+}
 async function selectYesNo(question, defaultYes = false) {
   return select(
     question,
@@ -4258,6 +4349,9 @@ function findDispatchGuards(sources) {
   const dynamic = /(?<![\w$.])[A-Za-z_$]*[gG]uard\(\s*(?!['"`])[A-Za-z_$][\w$.]*(?:\[[^\]\n]{1,40}\])?\s*[,)]/;
   return sources.filter(({ text }) => imports.test(text) && dynamic.test(stripDefinitions(text))).map(({ file }) => file);
 }
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\/]/g, "\\$&");
+}
 function stripDefinitions(text) {
   return text.replace(/\b(?:function|def)\s+[A-Za-z_$]*[gG]uard\s*\(/g, "");
 }
@@ -4267,6 +4361,11 @@ function toCamel(key) {
 function findGuardedKeys(sources) {
   const found = /* @__PURE__ */ new Map();
   const pattern = /(?:\b|@)(?:[A-Za-z_$]*[gG]uard|[A-Za-z_$]*[cC]heckpoint)\(\s*['"]([a-z][a-z0-9_]*)['"]/g;
+  for (const { file, text } of sources) {
+    for (const [key, where] of dynamicCheckpointKeys(text, file)) {
+      if (!found.has(key)) found.set(key, where);
+    }
+  }
   for (const { file, text } of sources) {
     for (const match of text.matchAll(pattern)) {
       const key = match[1];
@@ -4275,6 +4374,24 @@ function findGuardedKeys(sources) {
   }
   return found;
 }
+function dynamicCheckpointKeys(text, file) {
+  const found = [];
+  const calls = /(?<![\w$.])[A-Za-z_$]*[cC]heckpoint\(\s*([A-Za-z_$][\w$]*(?:\s*(?:\?\.|\.)\s*[A-Za-z_$][\w$]*)*)\s*[,)]/g;
+  for (const call of text.matchAll(calls)) {
+    const expression = (call[1] ?? "").replace(/\s+/g, "");
+    if (expression === "") continue;
+    const head = text.slice(Math.max(0, (call.index ?? 0) - 600), call.index ?? 0);
+    const [object, ...rest] = expression.split(".");
+    if (object === void 0) continue;
+    const access = rest.map((part) => `\\s*(?:\\?\\.|\\.)\\s*${escapeRegex(part)}`).join("");
+    const pattern = new RegExp(
+      `(?<![\\w$.])${escapeRegex(object)}${access}\\s*={2,3}\\s*['"\`]([a-z][a-z0-9_]*)['"\`]`,
+      "g"
+    );
+    for (const match of head.matchAll(pattern)) found.push([match[1], file]);
+  }
+  return found;
+}
 var PROVIDER_ENV = {
   anthropic: "ANTHROPIC_API_KEY",
   openai: "OPENAI_API_KEY"
@@ -5006,7 +5123,20 @@ var SKIP_DIRECTORIES = /* @__PURE__ */ new Set([
 var SKIP_FILES = /\.(test|spec)\.[cm]?[jt]sx?$|^test_.*\.py$|_test\.py$|\.d\.ts$|\.min\.[cm]?js$/;
 var DEFAULT_BUDGET_MS = 6e4;
 var MAX_PARSE_BYTES = 4 * 1024 * 1024;
+var cache = /* @__PURE__ */ new Map();
+function forgetIndex(root) {
+  if (root === void 0) cache.clear();
+  else cache.delete(path7.resolve(root));
+}
 function indexFiles(root, options = {}) {
+  const key = path7.resolve(root);
+  const hit = cache.get(key);
+  if (hit) return hit;
+  const built = buildIndex(root, options);
+  if (!built.truncated) cache.set(key, built);
+  return built;
+}
+function buildIndex(root, options) {
   const deadline2 = Date.now() + (options.budgetMs ?? DEFAULT_BUDGET_MS);
   const fromGit = gitFiles(root, deadline2);
   if (fromGit) {
@@ -5266,8 +5396,8 @@ function listSources(root = process.cwd()) {
   const index = indexFiles(root);
   return { files: index.files, truncated: index.truncated, method: index.method };
 }
-function discoverAgents(root = process.cwd()) {
-  const scan = scanProject(root);
+function discoverAgents(root = process.cwd(), reuse) {
+  const scan = reuse ?? scanProject(root);
   const index = indexFiles(root);
   const byDirectory = /* @__PURE__ */ new Map();
   for (const tool of scan.tools) {
@@ -5391,7 +5521,7 @@ function combineRisk(inferred, declared) {
 function findJsTools(text) {
   const hits = [];
   const importsFrom = (pkg) => new RegExp(
-    `from\\s+['"]${escapeRegex(pkg)}(/[^'"]*)?['"]|require\\(\\s*['"]${escapeRegex(pkg)}`
+    `from\\s+['"]${escapeRegex2(pkg)}(/[^'"]*)?['"]|require\\(\\s*['"]${escapeRegex2(pkg)}`
   ).test(text);
   const vercel = importsFrom("ai");
   const langchain = importsFrom("@langchain/core") || importsFrom("langchain");
@@ -5924,7 +6054,7 @@ function push(map, key, value) {
 function unique(values) {
   return [...new Set(values)];
 }
-function escapeRegex(value) {
+function escapeRegex2(value) {
   return value.replace(/[.*+?^${}()|[\]\\/]/g, "\\$&");
 }
 
@@ -6528,6 +6658,185 @@ function guardDispatch(source, fn, typescript) {
   return { after, at: target.start };
 }
 var CHECKPOINT_ARG_PROPERTIES = ["args", "arguments", "params", "parameters", "input", "payload"];
+var CONTROL_KEYWORDS = /* @__PURE__ */ new Set([
+  "if",
+  "else",
+  "for",
+  "while",
+  "do",
+  "switch",
+  "catch",
+  "with",
+  "return",
+  "typeof",
+  "await",
+  "new",
+  "throw",
+  "case",
+  "function",
+  "delete",
+  "void",
+  "in",
+  "of",
+  "yield"
+]);
+var BRANCH_KEYWORDS = /* @__PURE__ */ new Set(["if", "for", "while"]);
+function readStructure(source) {
+  const parens = [];
+  const blocks = [];
+  const parenStack = [];
+  const braceStack = [];
+  const closedAt = /* @__PURE__ */ new Map();
+  let awaitingBody = null;
+  let previous = "";
+  let index = 0;
+  while (index < source.length) {
+    const char = source[index];
+    const next = source[index + 1];
+    if (char === "/" && next === "/") {
+      const stop = source.indexOf("\n", index);
+      index = stop < 0 ? source.length : stop;
+      continue;
+    }
+    if (char === "/" && next === "*") {
+      const stop = source.indexOf("*/", index + 2);
+      index = stop < 0 ? source.length : stop + 2;
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      const stop = skipString(source, index);
+      index = stop < 0 ? nextLine(source, index) : stop;
+      previous = "a";
+      continue;
+    }
+    if (char === "`") {
+      const stop = skipTemplate(source, index);
+      index = stop < 0 ? nextLine(source, index) : stop;
+      previous = "a";
+      continue;
+    }
+    if (char === "/" && regexAllowed(source, index, previous)) {
+      const stop = skipRegex(source, index);
+      index = stop < 0 ? nextLine(source, index) : stop;
+      previous = "a";
+      continue;
+    }
+    if (char === "(") parenStack.push(index);
+    else if (char === ")") {
+      const open = parenStack.pop();
+      if (open !== void 0) {
+        const head = headBefore(source, open);
+        const group = { open, close: index, name: head.name, async: head.async };
+        parens.push(group);
+        closedAt.set(index, group);
+        if (!CONTROL_KEYWORDS.has(group.name) && /^\s*:/.test(source.slice(index + 1, index + 40))) {
+          awaitingBody = { async: group.async, depth: braceStack.length, params: group };
+        }
+      }
+    } else if (char === ";" || char === "=") {
+      if (awaitingBody && braceStack.length === awaitingBody.depth) awaitingBody = null;
+    } else if (char === "{") {
+      const kind = bodyKind(source, index, closedAt, awaitingBody);
+      if (kind.fn) awaitingBody = null;
+      braceStack.push({ open: index, ...kind });
+    } else if (char === "}") {
+      const open = braceStack.pop();
+      if (open !== void 0) blocks.push({ ...open, close: index });
+    }
+    if (!/\s/.test(char)) previous = char;
+    index += 1;
+  }
+  for (const open of braceStack) blocks.push({ ...open, close: source.length });
+  return { parens, blocks };
+}
+function nextLine(source, from) {
+  const stop = source.indexOf("\n", from);
+  return stop < 0 ? source.length : stop + 1;
+}
+function bodyKind(source, index, closedAt, awaitingBody) {
+  const before = significantBefore(source, index);
+  if (before.text === "=>") {
+    let cursor = before.at - 1;
+    while (cursor >= 0 && /\s/.test(source[cursor])) cursor -= 1;
+    const group = source[cursor] === ")" ? closedAt.get(cursor) : void 0;
+    if (group) return { fn: true, async: group.async, params: group };
+    return { fn: true, async: asyncBefore(source, cursor + 1), params: null };
+  }
+  if (before.text === ")") {
+    const group = closedAt.get(before.at);
+    if (!group) return { fn: false, async: false, params: null };
+    if (CONTROL_KEYWORDS.has(group.name)) return { fn: false, async: false, params: null };
+    return { fn: true, async: group.async, params: group };
+  }
+  if (awaitingBody && /[>\])\w$]/.test(before.text)) {
+    return { fn: true, async: awaitingBody.async, params: awaitingBody.params };
+  }
+  return { fn: false, async: false, params: null };
+}
+function significantBefore(source, index) {
+  let cursor = index - 1;
+  for (; ; ) {
+    while (cursor >= 0 && /\s/.test(source[cursor])) cursor -= 1;
+    if (cursor >= 1 && source[cursor] === "/" && source[cursor - 1] === "*") {
+      const open = source.lastIndexOf("/*", cursor - 1);
+      if (open < 0) break;
+      cursor = open - 1;
+      continue;
+    }
+    break;
+  }
+  if (cursor < 0) return { text: "", at: 0 };
+  if (cursor >= 1 && source[cursor] === ">" && source[cursor - 1] === "=") {
+    return { text: "=>", at: cursor - 1 };
+  }
+  return { text: source[cursor], at: cursor };
+}
+function headBefore(source, parenOpen) {
+  let cursor = parenOpen - 1;
+  while (cursor >= 0 && /\s/.test(source[cursor])) cursor -= 1;
+  let end = cursor + 1;
+  while (cursor >= 0 && /[\w$]/.test(source[cursor])) cursor -= 1;
+  const name = source.slice(cursor + 1, end);
+  let before = cursor;
+  if (name === "") {
+    return { name: "", async: asyncBefore(source, parenOpen) };
+  }
+  if (name === "async") return { name: "", async: true };
+  while (before >= 0 && /[\s*]/.test(source[before])) before -= 1;
+  end = before + 1;
+  while (before >= 0 && /[\w$]/.test(source[before])) before -= 1;
+  const keyword = source.slice(before + 1, end);
+  if (keyword === "function") return { name, async: asyncBefore(source, before + 1) };
+  return { name, async: asyncBefore(source, cursor + 1) };
+}
+function asyncBefore(source, at) {
+  let cursor = at - 1;
+  while (cursor >= 0 && /[\s*]/.test(source[cursor])) cursor -= 1;
+  const end = cursor + 1;
+  while (cursor >= 0 && /[\w$]/.test(source[cursor])) cursor -= 1;
+  return source.slice(cursor + 1, end) === "async";
+}
+function innermost(list, at) {
+  return enclosing(list, at)[0] ?? null;
+}
+function enclosing(list, at) {
+  return list.filter((item) => at > item.open && at <= item.close).sort((a, b) => b.open - a.open);
+}
+function enclosingArguments(source, structure, at) {
+  const body = innermost(
+    structure.blocks.filter((block) => block.fn && block.params !== null),
+    at
+  );
+  if (!body?.params) return null;
+  return parameterExpression(source.slice(body.params.open + 1, body.params.close));
+}
+function awaitAllowed(structure, at) {
+  const body = innermost(
+    structure.blocks.filter((block) => block.fn),
+    at
+  );
+  return body ? body.async : null;
+}
 function planCheckpoints(files, read, toolKeys) {
   const plans = [];
   const outstanding = new Set(toolKeys);
@@ -6541,24 +6850,41 @@ function planCheckpoints(files, read, toolKeys) {
       (key) => source.includes(key) || source.includes(camelOf(key))
     );
     if (present.length === 0) continue;
-    const scopes = functionScopes(source);
+    const structure = readStructure(source);
     const lineOf = lineLocator2(source);
     const alias = chooseAliasFor(source, "checkpoint", "js");
-    const edits = [];
-    const placed = [];
+    const sites = /* @__PURE__ */ new Map();
     for (const key of present) {
-      const site = checkpointSite(source, key, scopes);
+      const site = checkpointSite(source, key, structure);
       if (!site) continue;
-      const indent = blockIndent(source, site.at);
+      const existing = sites.get(site.at);
+      if (existing) existing.keys.push(key);
+      else sites.set(site.at, { keys: [key], site });
+    }
+    if (sites.size === 0) continue;
+    const edits = [];
+    const placed = [];
+    for (const [at, { keys, site }] of sites) {
+      if (/^\s*(?:await\s+)?[A-Za-z_$]*[cC]heckpoint\(/.test(source.slice(at, at + 200))) continue;
+      const many = keys.length > 1 || site.shared === true;
+      const keyExpression = many && site.keyExpression ? site.keyExpression : quote(keys[0] ?? "");
+      if (many && !site.keyExpression) continue;
       const args = site.argsExpression ? `, ${site.argsExpression}` : "";
       edits.push({
-        start: site.at,
-        end: site.at,
+        start: at,
+        end: at,
         text: `
-${indent}await ${alias}(${quote(key)}${args});`
+${blockIndent(source, at)}await ${alias}(${keyExpression}${args});`
       });
-      placed.push({ key, line: lineOf(site.at), shape: site.shape });
-      outstanding.delete(key);
+      for (const key of keys) {
+        placed.push({
+          key,
+          line: lineOf(at),
+          shape: site.shape,
+          ...many ? { dynamic: true } : {}
+        });
+        outstanding.delete(key);
+      }
     }
     if (edits.length === 0) continue;
     const after = addJsSdkImport(applyEdits(source, edits), "checkpoint", alias);
@@ -6566,30 +6892,97 @@ ${indent}await ${alias}(${quote(key)}${args});`
   }
   return plans;
 }
-function checkpointSite(source, key, scopes) {
+function planCheckpointRepairs(files, read, toolKeys) {
+  const plans = [];
+  const known = new Set(toolKeys);
+  for (const file of files) {
+    if (file.endsWith(".py") || !JS_EXTENSIONS.test(file)) continue;
+    const source = read(file);
+    if (source === null || !/[cC]heckpoint\(/.test(source)) continue;
+    const structure = readStructure(source);
+    const lineOf = lineLocator2(source);
+    const edits = [];
+    const placed = [];
+    const calls = /(?<![\w$.])([A-Za-z_$]*[cC]heckpoint)\(\s*(['"`])([a-z][a-z0-9_]*)\2/g;
+    for (const match of source.matchAll(calls)) {
+      const key = match[3];
+      if (!known.has(key)) continue;
+      const at = match.index ?? 0;
+      const group = enclosing(structure.parens, at).find(
+        (candidate) => BRANCH_KEYWORDS.has(candidate.name)
+      );
+      const head = group ?? innermostBranchAbove(source, structure, at);
+      if (!head) continue;
+      const compared = comparedKeyExpression(source, head, key);
+      if (!compared) continue;
+      const served = branchKeys(source, head, compared);
+      if (served.length < 2 || !served.includes(key)) continue;
+      const keyStart = at + match[0].indexOf(match[2], match[1].length);
+      edits.push({ start: keyStart, end: keyStart + (key.length + 2), text: compared });
+      for (const served_key of served) {
+        placed.push({ key: served_key, line: lineOf(at), shape: "branch", dynamic: true });
+      }
+    }
+    if (edits.length === 0) continue;
+    plans.push({ file, before: source, after: applyEdits(source, edits), placed });
+  }
+  return plans;
+}
+function innermostBranchAbove(source, structure, at) {
+  const body = innermost(
+    structure.blocks.filter((block) => !block.fn),
+    at
+  );
+  if (!body) return null;
+  return structure.parens.filter((group) => BRANCH_KEYWORDS.has(group.name) && group.close < body.open).sort((a, b) => b.close - a.close)[0] ?? null;
+}
+function comparedKeyExpression(source, head, key) {
+  const text = source.slice(head.open, head.close);
+  const pattern = new RegExp(
+    `(?<![\\w$.])([A-Za-z_$][\\w$]*(?:\\s*(?:\\?\\.|\\.)\\s*[A-Za-z_$][\\w$]*)*)\\s*={2,3}\\s*['"\`]${escapeForRegex(key)}['"\`]`
+  );
+  const found = pattern.exec(text);
+  return found ? found[1].replace(/\s+/g, "") : null;
+}
+function checkpointSite(source, key, structure) {
   const quoted = `['"\`]${escapeForRegex(key)}['"\`]`;
-  const usable = (at) => enclosingAsync(scopes, at) === true;
+  const usable = (at) => awaitAllowed(structure, at) === true;
+  const bodyAfter = (close) => {
+    const brace = /^\s*\{/.exec(source.slice(close + 1, close + 200));
+    return brace ? close + 1 + brace[0].length : null;
+  };
   for (const match of source.matchAll(new RegExp(`\\bcase\\s+${quoted}\\s*:`, "g"))) {
     const colon = (match.index ?? 0) + match[0].length;
     const braced = /^\s*\{/.exec(source.slice(colon));
     const at = braced ? colon + braced[0].length : colon;
     if (!usable(at)) continue;
-    return { at, shape: "case", argsExpression: switchArguments(source, match.index ?? 0) };
-  }
-  const comparison = new RegExp(
-    `(?:if|else\\s+if)\\s*\\(([^()]{0,200}?)${quoted}([^()]{0,200}?)\\)\\s*\\{`,
-    "g"
-  );
-  for (const match of source.matchAll(comparison)) {
-    const left = match[1] ?? "";
-    if (!/(?<![!<>])={2,3}\s*$/.test(left)) continue;
-    const at = (match.index ?? 0) + match[0].length;
-    if (!usable(at)) continue;
-    const object = /([A-Za-z_$][\w$]*)\s*(?:\?\.|\.)\s*[A-Za-z_$][\w$]*\s*={2,3}\s*$/.exec(left);
+    const discriminant = switchKey(source, match.index ?? 0);
     return {
       at,
-      shape: "branch",
-      argsExpression: object ? argumentsOf(source, object[1]) : null
+      shape: "case",
+      argsExpression: discriminant ? argumentsOf(source, discriminant.object) : null,
+      keyExpression: discriminant?.expression ?? null
+    };
+  }
+  for (const match of source.matchAll(new RegExp(quoted, "g"))) {
+    const at = match.index ?? 0;
+    if (!positiveComparison(source, at)) continue;
+    const group = enclosing(structure.parens, at).find(
+      (candidate) => BRANCH_KEYWORDS.has(candidate.name)
+    );
+    if (!group) continue;
+    const insertAt = bodyAfter(group.close);
+    if (insertAt === null || !usable(insertAt)) continue;
+    const compared = comparedExpression(source, at);
+    const loop = group.name === "for" ? loopVariable(source, group.open) : null;
+    const subject = loop ?? compared?.object ?? null;
+    const served = compared ? branchKeys(source, group, compared.expression) : [];
+    return {
+      at: insertAt,
+      shape: group.name === "if" ? "branch" : "loop",
+      argsExpression: subject ? argumentsOf(source, subject) : enclosingArguments(source, structure, insertAt),
+      keyExpression: loop ? `${loop}.name` : compared?.expression ?? null,
+      shared: served.length > 1
     };
   }
   const declaration = new RegExp(
@@ -6599,18 +6992,23 @@ function checkpointSite(source, key, scopes) {
   for (const match of source.matchAll(declaration)) {
     const name = match[1];
     const end = (match.index ?? 0) + match[0].length;
-    const head = new RegExp(`^\\s*if\\s*\\(\\s*${escapeForRegex(name)}\\b`).exec(
-      source.slice(end, end + 200)
+    const block = innermost(structure.blocks, end);
+    const limit = block ? block.close : source.length;
+    const head = new RegExp(`\\bif\\s*\\(\\s*${escapeForRegex(name)}\\b`).exec(
+      source.slice(end, limit)
     );
     if (!head) continue;
-    const parenOpen = end + head[0].lastIndexOf("(", head[0].length - name.length);
-    const parenClose = matchBracket(source, parenOpen);
-    if (parenClose < 0) continue;
-    const brace = /^\s*\{/.exec(source.slice(parenClose + 1));
-    if (!brace) continue;
-    const at = parenClose + 1 + brace[0].length;
-    if (!usable(at)) continue;
-    return { at, shape: "found", argsExpression: argumentsOf(source, name) };
+    const parenOpen = end + (head.index ?? 0) + head[0].indexOf("(");
+    const group = structure.parens.find((candidate) => candidate.open === parenOpen);
+    if (!group) continue;
+    const insertAt = bodyAfter(group.close);
+    if (insertAt === null || !usable(insertAt)) continue;
+    return {
+      at: insertAt,
+      shape: "found",
+      argsExpression: argumentsOf(source, name),
+      keyExpression: `${name}.name`
+    };
   }
   const handler = new RegExp(
     `${quoted}\\s*:\\s*(?:async\\s*)?\\(([^)]{0,200})\\)\\s*(?::[^=>{]{0,120})?=>\\s*\\{`,
@@ -6619,28 +7017,68 @@ function checkpointSite(source, key, scopes) {
   for (const match of source.matchAll(handler)) {
     const at = (match.index ?? 0) + match[0].length;
     if (!usable(at)) continue;
-    return { at, shape: "handler", argsExpression: parameterExpression(match[1] ?? "") };
+    return {
+      at,
+      shape: "handler",
+      argsExpression: parameterExpression(match[1] ?? ""),
+      keyExpression: null
+    };
   }
-  const camel = camelOf(key);
   const named = new RegExp(
-    `\\basync\\s+function\\s+(?:${escapeForRegex(camel)}|${escapeForRegex(key)})\\s*\\(`,
+    `\\basync\\s+function\\s+(?:${escapeForRegex(camelOf(key))}|${escapeForRegex(key)})\\s*\\(`,
     "g"
   );
   for (const match of source.matchAll(named)) {
     const parenOpen = (match.index ?? 0) + match[0].length - 1;
-    const parenClose = matchBracket(source, parenOpen);
-    if (parenClose < 0) continue;
-    const bodyOpen = source.indexOf("{", parenClose);
-    if (bodyOpen < 0) continue;
-    if (!/^\s*(?::[^{;]*)?$/.test(source.slice(parenClose + 1, bodyOpen))) continue;
+    const group = structure.parens.find((candidate) => candidate.open === parenOpen);
+    if (!group) continue;
+    const body = structure.blocks.filter((block) => block.fn && block.open > group.close).sort((a, b) => a.open - b.open)[0];
+    if (!body) continue;
     return {
-      at: bodyOpen + 1,
+      at: body.open + 1,
       shape: "function",
-      argsExpression: parameterExpression(source.slice(parenOpen + 1, parenClose))
+      argsExpression: parameterExpression(source.slice(group.open + 1, group.close)),
+      keyExpression: null
     };
   }
   return null;
 }
+function positiveComparison(source, at) {
+  const before = source.slice(Math.max(0, at - 96), at);
+  return /(?<![!<>])={2,3}\s*$/.test(before);
+}
+function comparedExpression(source, at) {
+  const before = source.slice(Math.max(0, at - 160), at);
+  const member = /([A-Za-z_$][\w$]*)\s*(?:\?\.|\.)\s*([A-Za-z_$][\w$]*)\s*={2,3}\s*$/.exec(before);
+  if (member) return { object: member[1], expression: `${member[1]}.${member[2]}` };
+  const bare = /(?<![\w$.])([A-Za-z_$][\w$]*)\s*={2,3}\s*$/.exec(before);
+  if (bare) return { object: null, expression: bare[1] };
+  return null;
+}
+function branchKeys(source, group, expression) {
+  const head = source.slice(group.open, group.close);
+  const [object, ...rest] = expression.split(".");
+  if (object === void 0) return [];
+  const access = rest.map((part) => `\\s*(?:\\?\\.|\\.)\\s*${escapeForRegex(part)}`).join("");
+  const pattern = new RegExp(
+    `(?<![\\w$.])${escapeForRegex(object)}${access}\\s*={2,3}\\s*['"\`]([a-z][a-z0-9_]*)['"\`]`,
+    "g"
+  );
+  return [...new Set([...head.matchAll(pattern)].map((match) => match[1]))];
+}
+function switchKey(source, at) {
+  const before = source.slice(Math.max(0, at - 4e3), at);
+  const found = [
+    ...before.matchAll(/\bswitch\s*\(\s*([A-Za-z_$][\w$]*)\s*(?:\?\.|\.)\s*([A-Za-z_$][\w$]*)/g)
+  ];
+  const last = found[found.length - 1];
+  return last ? { object: last[1], expression: `${last[1]}.${last[2]}` } : null;
+}
+function loopVariable(source, parenOpen) {
+  return /^\s*\(\s*(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s+of\b/.exec(
+    source.slice(parenOpen, parenOpen + 120)
+  )?.[1] ?? null;
+}
 function parameterExpression(parameters) {
   const names = parameters.split(",").map((part) => /^\s*(?:\.\.\.)?([A-Za-z_$][\w$]*)/.exec(part)?.[1]).filter((name) => name !== void 0);
   const named = names.find((name) => CHECKPOINT_ARG_PROPERTIES.includes(name));
@@ -6650,14 +7088,6 @@ function parameterExpression(parameters) {
 function camelOf(key) {
   return key.replace(/_([a-z0-9])/g, (_match, char) => char.toUpperCase());
 }
-function switchArguments(source, at) {
-  const before = source.slice(Math.max(0, at - 4e3), at);
-  const found = [
-    ...before.matchAll(/\bswitch\s*\(\s*([A-Za-z_$][\w$]*)\s*(?:\?\.|\.)\s*[A-Za-z_$][\w$]*/g)
-  ];
-  const last = found[found.length - 1];
-  return last ? argumentsOf(source, last[1]) : null;
-}
 function argumentsOf(source, object) {
   for (const property of CHECKPOINT_ARG_PROPERTIES) {
     const pattern = new RegExp(`\\b${escapeForRegex(object)}\\s*(?:\\?\\.|\\.)\\s*${property}\\b`);
@@ -6675,63 +7105,6 @@ function blockIndent(source, at) {
   const lineStart = source.lastIndexOf("\n", at) + 1;
   return `${/^[ \t]*/.exec(source.slice(lineStart, at))?.[0] ?? ""}  `;
 }
-function functionScopes(source) {
-  const scopes = [];
-  const add = (isAsync, parenOpen, arrow) => {
-    const parenClose = matchBracket(source, parenOpen);
-    if (parenClose < 0) return;
-    const bodyOpen = source.indexOf("{", parenClose);
-    if (bodyOpen < 0) return;
-    const between = source.slice(parenClose + 1, bodyOpen);
-    if (arrow !== /=>/.test(between)) return;
-    if (!/^\s*(?::[^{;=]*)?(?:=>\s*)?$/.test(between)) return;
-    const bodyClose = matchBracket(source, bodyOpen);
-    if (bodyClose < 0) return;
-    scopes.push({ bodyOpen, bodyClose, async: isAsync });
-  };
-  for (const match of source.matchAll(/\b(async\s+)?function\s*\*?\s*[A-Za-z_$][\w$]*\s*\(/g)) {
-    add(match[1] !== void 0, (match.index ?? 0) + match[0].length - 1, false);
-  }
-  for (const match of source.matchAll(/(\basync\s*)?\(/g)) {
-    add(match[1] !== void 0, (match.index ?? 0) + match[0].length - 1, true);
-  }
-  const method = /^[ \t]*((?:(?:public|private|protected|static|override|async|get|set)\s+)*)\*?\s*([A-Za-z_$][\w$]*)\s*\(/gm;
-  for (const match of source.matchAll(method)) {
-    if (CONTROL_KEYWORDS.has(match[2])) continue;
-    add(/\basync\b/.test(match[1] ?? ""), (match.index ?? 0) + match[0].length - 1, false);
-  }
-  for (const match of source.matchAll(/\b(async\s+)?([A-Za-z_$][\w$]*)\s*=>\s*\{/g)) {
-    const bodyOpen = (match.index ?? 0) + match[0].length - 1;
-    const bodyClose = matchBracket(source, bodyOpen);
-    if (bodyClose > 0) scopes.push({ bodyOpen, bodyClose, async: match[1] !== void 0 });
-  }
-  return scopes;
-}
-var CONTROL_KEYWORDS = /* @__PURE__ */ new Set([
-  "if",
-  "else",
-  "for",
-  "while",
-  "do",
-  "switch",
-  "catch",
-  "with",
-  "return",
-  "typeof",
-  "new",
-  "await",
-  "function",
-  "throw",
-  "case"
-]);
-function enclosingAsync(scopes, at) {
-  let best = null;
-  for (const scope of scopes) {
-    if (at <= scope.bodyOpen || at > scope.bodyClose) continue;
-    if (!best || scope.bodyOpen > best.bodyOpen) best = scope;
-  }
-  return best ? best.async : null;
-}
 function unguardJs(source) {
   const checkpoints = uncheckpointJs(source);
   const imported = jsGuardImport(checkpoints.after);
@@ -6788,9 +7161,10 @@ function uncheckpointJs(source) {
   const lineOf = lineLocator2(source);
   const leftovers = [];
   let removed = 0;
+  const key = `(?:(['"\`])[a-z][a-z0-9_]*\\1|[A-Za-z_$][\\w$]*(?:\\s*(?:\\?\\.|\\.)\\s*[A-Za-z_$][\\w$]*)+)`;
   let after = source.replace(
     new RegExp(
-      `^[ \\t]*(?:await[ \\t]+)?${escapeForRegex(alias)}\\(\\s*(['"\`])[a-z][a-z0-9_]*\\1[^\\n]*\\)[ \\t]*;?[ \\t]*\\r?\\n`,
+      `^[ \\t]*(?:await[ \\t]+)?${escapeForRegex(alias)}\\(\\s*${key}[^\\n]*\\)[ \\t]*;?[ \\t]*\\r?\\n`,
       "gm"
     ),
     () => {
@@ -6812,8 +7186,28 @@ function uncheckpointJs(source) {
 function unguardPython(source) {
   const imported = /^from[ \t]+veefore[ \t]+import[ \t]+([^\n]+)$/m.exec(source);
   if (!imported) return { after: source, removed: 0, leftovers: [] };
-  const spec = (imported[1] ?? "").replace(/[()]/g, "").split(",").map((part) => /^guard(?:\s+as\s+(\w+))?$/.exec(part.trim())).find((found) => found !== null);
-  if (!spec) return { after: source, removed: 0, leftovers: [] };
+  const names = (imported[1] ?? "").replace(/[()]/g, "").split(",");
+  const spec = names.map((part) => /^guard(?:\s+as\s+(\w+))?$/.exec(part.trim())).find((found) => found !== null);
+  const gate = names.map((part) => /^checkpoint(?:\s+as\s+(\w+))?$/.exec(part.trim())).find((found) => found !== null);
+  if (!spec && !gate) return { after: source, removed: 0, leftovers: [] };
+  if (!spec) {
+    const alias2 = gate?.[1] ?? "checkpoint";
+    let removed2 = 0;
+    let after2 = source.replace(
+      new RegExp(
+        `^[ \\t]*${escapeForRegex(alias2)}\\(\\s*(['"])[a-z][a-z0-9_]*\\1[^\\n]*\\)[ \\t]*\\r?\\n`,
+        "gm"
+      ),
+      () => {
+        removed2 += 1;
+        return "";
+      }
+    );
+    if (!new RegExp(`(?<![\\w.])${escapeForRegex(alias2)}\\s*\\(`).test(after2)) {
+      after2 = removePythonImport(after2, alias2);
+    }
+    return { after: after2, removed: removed2, leftovers: [] };
+  }
   const alias = spec[1] ?? "guard";
   const lineOf = lineLocator2(source);
   let removed = 0;
@@ -6852,18 +7246,20 @@ function unguardPython(source) {
   after = applyEdits(after, edits);
   removed += edits.length;
   const stillUsed = new RegExp(`(?<![\\w.])@?${escapeForRegex(alias)}\\s*\\(`).test(after);
-  if (!stillUsed) {
-    after = after.replace(
-      /^from[ \t]+veefore[ \t]+import[ \t]+([^\n]+)\r?\n?/m,
-      (line, names) => {
-        const rest = names.replace(/[()]/g, "").split(",").map((part) => part.trim()).filter((part) => part && !/^guard(?:\s+as\s+\w+)?$/.test(part));
-        return rest.length === 0 ? "" : `from veefore import ${rest.join(", ")}
-`;
-      }
-    );
-  }
+  if (!stillUsed) after = removePythonImport(after, "guard");
   return { after, removed, leftovers };
 }
+function removePythonImport(source, name) {
+  const target = new RegExp(`^${escapeForRegex(name)}(?:\\s+as\\s+\\w+)?$`);
+  return source.replace(
+    /^from[ \t]+veefore[ \t]+import[ \t]+([^\n]+)\r?\n?/m,
+    (_line, names) => {
+      const rest = names.replace(/[()]/g, "").split(",").map((part) => part.trim()).filter((part) => part && !target.test(part));
+      return rest.length === 0 ? "" : `from veefore import ${rest.join(", ")}
+`;
+    }
+  );
+}
 function arrowExpressionBody(fn) {
   let cursor = 0;
   if (fn.startsWith("(")) {
@@ -7107,7 +7503,6 @@ async function integrate(root, toolKeys, options) {
   const candidates = shortlist(root, index, anchors);
   const sourceFiles = candidates.files;
   const truncated = index.truncated || candidates.truncated;
-  const plan = planRewrite(root, sourceFiles, toolKeys);
   const interactive = options.interactive ?? (process.stdin.isTTY === true && process.stdout.isTTY === true && !options.yes);
   if (truncated && !options.quiet) {
     out(
@@ -7118,13 +7513,39 @@ async function integrate(root, toolKeys, options) {
   const dispatchGuardFiles = findDispatchGuards(sources);
   const dispatchGuarded = dispatchGuardFiles.length > 0;
   const alreadyGuarded = guardedToolKeys(sources, toolKeys);
-  for (const file of plan.files) {
-    for (const change of file.changes) {
-      if (change.status === "manual" && alreadyGuarded.has(change.key)) {
-        change.status = "already";
-        delete change.reason;
+  const reconcile = (result) => {
+    for (const file of result.files) {
+      for (const change of file.changes) {
+        if (change.status === "manual" && alreadyGuarded.has(change.key)) {
+          change.status = "already";
+          delete change.reason;
+        }
       }
     }
+    return result;
+  };
+  let plan = reconcile(planRewrite(root, sourceFiles, toolKeys));
+  const changeable = [
+    ...new Set(
+      plan.files.flatMap(
+        (file) => file.changes.filter((change) => change.status !== "already").map((change) => change.key)
+      )
+    )
+  ];
+  const selected = await chooseTools(changeable, plan, {
+    requested: options.tools,
+    interactive,
+    quiet: options.quiet === true
+  });
+  const skipped = changeable.filter((key) => !selected.includes(key));
+  if (skipped.length > 0) {
+    plan = reconcile(
+      planRewrite(
+        root,
+        sourceFiles,
+        toolKeys.filter((key) => !skipped.includes(key))
+      )
+    );
   }
   let manual = plan.files.flatMap(
     (file) => file.changes.filter((change) => change.status === "manual").map((change) => ({
@@ -7157,6 +7578,15 @@ async function integrate(root, toolKeys, options) {
       dispatch = [];
     }
   }
+  const repaired = applyCheckpoints(
+    plan,
+    planCheckpointRepairs(sourceFiles, (file) => currentText(root, plan, file), toolKeys)
+  );
+  if (repaired.size > 0 && !options.quiet) {
+    out(
+      `${symbol.warn} Corrected a guard that named one tool in a block that runs several: ${style.bold([...repaired].join(", "))} ${style.grey("(it now carries the key your code read)")}`
+    );
+  }
   if (dispatch.length > 0 && checkpointUsable(root, options.quiet === true)) {
     const placed = applyCheckpoints(
       plan,
@@ -7270,7 +7700,15 @@ async function integrate(root, toolKeys, options) {
       reportSdkReadiness(root, [.../* @__PURE__ */ new Set([...guardedFiles, ...dispatchGuardFiles])]);
     }
     const unguarded2 = reportProtection(root, sourceFiles, toolKeys, quiet);
-    return { status: "nothing-to-do", plan, checks: [], backupId: null, manual, unguarded: unguarded2 };
+    return {
+      status: "nothing-to-do",
+      plan,
+      checks: [],
+      backupId: null,
+      manual,
+      unguarded: unguarded2,
+      skipped
+    };
   }
   if (options.dryRun) {
     out(style.grey("Dry run: nothing was written."));
@@ -7280,7 +7718,8 @@ async function integrate(root, toolKeys, options) {
       checks: [],
       backupId: null,
       manual,
-      unguarded: reportProtection(root, sourceFiles, toolKeys, true)
+      unguarded: reportProtection(root, sourceFiles, toolKeys, true),
+      skipped
     };
   }
   if (!options.quiet) {
@@ -7301,7 +7740,8 @@ async function integrate(root, toolKeys, options) {
       checks: [],
       backupId: null,
       manual,
-      unguarded: reportProtection(root, sourceFiles, toolKeys, true)
+      unguarded: reportProtection(root, sourceFiles, toolKeys, true),
+      skipped
     };
   }
   const jsReady = languages.has("js") && sdkInstalled(root, "js");
@@ -7318,12 +7758,14 @@ async function integrate(root, toolKeys, options) {
         checks: [],
         backupId: null,
         manual,
-        unguarded: reportProtection(root, sourceFiles, toolKeys, true)
+        unguarded: reportProtection(root, sourceFiles, toolKeys, true),
+        skipped
       };
     }
   }
   const backup = createBackup(root, toWrite);
   for (const file of toWrite) writeFilePreservingMode(path10.join(root, file.file), file.after);
+  forgetIndex(root);
   out(
     `${symbol.pass} Updated ${toWrite.length} file${toWrite.length === 1 ? "" : "s"} ${style.grey(`(backup ${backup.id})`)}`
   );
@@ -7385,7 +7827,8 @@ async function integrate(root, toolKeys, options) {
       checks,
       backupId: null,
       manual,
-      unguarded: reportProtection(root, sourceFiles, toolKeys, true)
+      unguarded: reportProtection(root, sourceFiles, toolKeys, true),
+      skipped
     };
   }
   for (const language of languages) {
@@ -7395,9 +7838,14 @@ async function integrate(root, toolKeys, options) {
       );
     }
   }
+  if (skipped.length > 0 && !options.quiet) {
+    out(
+      `${symbol.info} Left out of this run, as you chose: ${style.bold(skipped.join(", "))} ${style.grey("(no file was changed for these)")}`
+    );
+  }
   const unguarded = reportProtection(root, sourceFiles, toolKeys, options.quiet === true);
   out(style.grey("  Undo at any time with `veefore undo`."));
-  return { status: "applied", plan, checks, backupId: backup.id, manual, unguarded };
+  return { status: "applied", plan, checks, backupId: backup.id, manual, unguarded, skipped };
 }
 function reportProtection(root, files, toolKeys, quiet) {
   const guarded = guardedToolKeys(readSources(root, files), toolKeys);
@@ -7560,6 +8008,43 @@ function stillManual(items, plan) {
     return true;
   });
 }
+async function chooseTools(changeable, plan, options) {
+  if (options.requested) {
+    const asked = new Set(options.requested);
+    const unknown = options.requested.filter((key) => !changeable.includes(key));
+    if (unknown.length > 0 && !options.quiet) {
+      out(
+        `${symbol.warn} Nothing to change for: ${unknown.join(", ")} ${style.grey("(already protected, or not found in the code)")}`
+      );
+    }
+    return changeable.filter((key) => asked.has(key));
+  }
+  if (!options.interactive || changeable.length < 2) return changeable;
+  const where = /* @__PURE__ */ new Map();
+  for (const file of plan.files) {
+    for (const change of file.changes) {
+      if (change.status === "already" || where.has(change.key)) continue;
+      where.set(change.key, { line: change.line, file: file.file, status: change.status });
+    }
+  }
+  try {
+    return await selectMany(
+      "Which tools should Veefore decide for?",
+      changeable.map((key) => {
+        const at = where.get(key);
+        return {
+          label: key,
+          value: key,
+          hint: at ? `${at.status === "wrapped" ? "guard here" : "needs a change"} \xB7 ${at.file}:${at.line}` : ""
+        };
+      }),
+      { help: "All of them unless you say otherwise. Only what is ticked gets changed." }
+    );
+  } catch (error) {
+    if (error instanceof MenuCancelled) return [];
+    throw error;
+  }
+}
 function checkpointUsable(root, quiet) {
   const sdks = installedSdks(root).filter((sdk) => sdk.language === "js");
   const stale = sdks.filter((sdk) => !sdk.hasCheckpoint);
@@ -7632,7 +8117,13 @@ function guardedToolKeys(sources, toolKeys) {
   return new Map([...guarded].filter(([key]) => toolKeys.includes(key)));
 }
 function checkIntegration(root, toolKeys) {
-  const guarded = guardedToolKeys(readSources(root), toolKeys);
+  const index = indexFiles(root);
+  const candidates = shortlist(root, index, [
+    ...toolKeyAnchors(toolKeys),
+    ...TOOL_ANCHORS,
+    ...GUARD_ANCHORS
+  ]);
+  const guarded = guardedToolKeys(readSources(root, candidates.files), toolKeys);
   heading("Protection check");
   for (const key of toolKeys) {
     const file = guarded.get(key);
@@ -7934,10 +8425,20 @@ async function integrateCommand(args, flags) {
   let assist;
   let dryRun = false;
   let check = false;
+  let tools;
   for (const arg of args) {
     if (arg === "--dry-run") dryRun = true;
     else if (arg === "--check") check = true;
-    else if (arg.startsWith("--assist=")) {
+    else if (arg === "--tools=all") tools = void 0;
+    else if (arg.startsWith("--tools=")) {
+      tools = arg.slice("--tools=".length).split(",").map((key) => key.trim()).filter((key) => key !== "");
+      if (tools.length === 0) {
+        throw new CliError(
+          "`--tools` takes a comma-separated list of tool keys, or `all`.",
+          "For example: --tools=refund_order,adjust_stock"
+        );
+      }
+    } else if (arg.startsWith("--assist=")) {
       const value = ASSIST_VALUES[arg.slice("--assist=".length)];
       if (!value) {
         throw new CliError(
@@ -7980,7 +8481,8 @@ async function integrateCommand(args, flags) {
     dryRun,
     quiet: flags.json,
     assist,
-    api
+    api,
+    ...tools ? { tools } : {}
   });
   if (flags.json) {
     out(
@@ -7992,6 +8494,7 @@ async function integrateCommand(args, flags) {
           not_found: outcome.plan.notFound,
           manual: outcome.manual,
           unguarded: outcome.unguarded,
+          skipped: outcome.skipped,
           checks: outcome.checks
         },
         null,
@@ -8394,7 +8897,7 @@ import { homedir as homedir2 } from "node:os";
 import path12 from "node:path";
 
 // src/version.ts
-var CLI_VERSION = "1.5.0";
+var CLI_VERSION = "1.6.1";
 
 // src/panel.ts
 function welcomeSource(flags = {}) {
@@ -8518,12 +9021,12 @@ function printScan(scan) {
       `${symbol.warn} Your code reads ${service.length} credential${service.length === 1 ? "" : "s"}: ${service.map((s) => s.name).join(", ")} ${style.grey("(names only; values were not read)")}`
     );
   }
-  printGaps(scan.root);
+  printGaps(scan);
 }
-function printGaps(root) {
+function printGaps(scan) {
   let discovery;
   try {
-    discovery = discoverAgents(root);
+    discovery = discoverAgents(scan.root, scan);
   } catch {
     return;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "veefore",
-  "version": "1.5.0",
+  "version": "1.6.1",
   "description": "Veefore command line: sign in, scan an agent project, set it up and protect its tools.",
   "license": "Apache-2.0",
   "homepage": "https://veefore.com",