pybao-cli 1.3.81 → 1.3.83

package/dist/{chunk-KZGNQII5.js → chunk-6VOYUVQU.js}

@@ -6,10 +6,10 @@ import {
 import {
   getSettingsFileCandidates,
   loadSettingsWithLegacyFallback
-} from "./chunk-LVTQN4RG.js";
+} from "./chunk-XC4AJGEW.js";
 import {
   getTheme
-} from "./chunk-LLNNHSE3.js";
+} from "./chunk-FH5VPA4M.js";
 import {
   addMcprcServerForTesting,
   getCurrentProjectConfig,
@@ -19,13 +19,13 @@ import {
   safeParseJSON,
   saveCurrentProjectConfig,
   saveGlobalConfig
-} from "./chunk-TMIQYE2C.js";
+} from "./chunk-JGJCX75W.js";
 import {
   PRODUCT_COMMAND,
   PRODUCT_NAME,
   getCwd,
   logMCPError
-} from "./chunk-Q653YYZS.js";
+} from "./chunk-L62UDJSU.js";
 
 // src/services/mcp/client.ts
 import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";

package/dist/{chunk-AED6OYMI.js → chunk-B3MDT4F6.js}

@@ -8,11 +8,11 @@ import {
 } from "./chunk-BJSWTHRM.js";
 import {
   loadSettingsWithLegacyFallback
-} from "./chunk-LVTQN4RG.js";
+} from "./chunk-XC4AJGEW.js";
 import {
   getCwd,
   logError
-} from "./chunk-Q653YYZS.js";
+} from "./chunk-L62UDJSU.js";
 
 // src/utils/session/pybHooks.ts
 import { spawn } from "child_process";
@@ -496,7 +496,7 @@ async function runPromptHook(args) {
     fallbackTimeoutMs: args.fallbackTimeoutMs
   });
   try {
-    const { queryQuick } = await import("./llmLazy-E37BRRJL.js");
+    const { queryQuick } = await import("./llmLazy-JT5FOMWS.js");
     const systemPrompt = [
       "You are executing a Pyb prompt hook.",
       "Return a single JSON object only (no markdown, no prose).",

package/dist/{chunk-JEHHIOUO.js → chunk-BPZ44BIE.js}

@@ -448,7 +448,7 @@ function getLastAssistantMessageId(messages) {
 
 // src/utils/messages/index.ts
 async function processUserInput(input, mode, setToolJSX, context, pastedImages) {
-  const impl = await import("./userInput-TBU35CMG.js");
+  const impl = await import("./userInput-EP4A6TDN.js");
   return impl.processUserInput(input, mode, setToolJSX, context, pastedImages);
 }
 

package/dist/{chunk-IV73XFVG.js → chunk-CPOVPGCU.js}

@@ -4,18 +4,18 @@ import {
   getSettingsFileCandidates,
   loadSettingsWithLegacyFallback,
   saveSettingsToPrimaryAndSyncLegacy
-} from "./chunk-LVTQN4RG.js";
+} from "./chunk-XC4AJGEW.js";
 import {
   createDefaultToolPermissionContext,
   isPersistableToolPermissionDestination
 } from "./chunk-UNNVICVU.js";
 import {
   getCurrentProjectConfig
-} from "./chunk-TMIQYE2C.js";
+} from "./chunk-JGJCX75W.js";
 import {
   getCwd,
   logError
-} from "./chunk-Q653YYZS.js";
+} from "./chunk-L62UDJSU.js";
 
 // src/utils/permissions/toolPermissionSettings.ts
 function uniqueStrings(value) {

package/dist/{chunk-LLNNHSE3.js → chunk-FH5VPA4M.js}

@@ -2,7 +2,7 @@ import { createRequire as __pybCreateRequire } from "node:module";
 const require = __pybCreateRequire(import.meta.url);
 import {
   getGlobalConfig
-} from "./chunk-TMIQYE2C.js";
+} from "./chunk-JGJCX75W.js";
 
 // src/utils/theme/index.ts
 var lightTheme = {

package/dist/{chunk-2RR4H3L6.js → chunk-FL4UY5X6.js}

@@ -5,11 +5,11 @@ import {
   getCLISyspromptPrefix,
   getReasoningEffort,
   models_default
-} from "./chunk-4YJ6DHQK.js";
+} from "./chunk-43ZJOQDX.js";
 import {
   getCompletionWithProfile,
   getGPT5CompletionWithProfile
-} from "./chunk-MTSI5244.js";
+} from "./chunk-WU4VY7XT.js";
 import {
   API_ERROR_MESSAGE_PREFIX,
   CREDIT_BALANCE_TOO_LOW_ERROR_MESSAGE,
@@ -18,7 +18,7 @@ import {
   PROMPT_TOO_LONG_ERROR_MESSAGE,
   createAssistantAPIErrorMessage,
   normalizeContentFromAPI
-} from "./chunk-JEHHIOUO.js";
+} from "./chunk-BPZ44BIE.js";
 import {
   processResponsesStream
 } from "./chunk-OMELVAJD.js";
@@ -30,11 +30,11 @@ import {
   USE_VERTEX,
   getModelManager,
   getVertexRegionForModel
-} from "./chunk-RPQ3FFN6.js";
+} from "./chunk-HMCPTTVR.js";
 import {
   getAnthropicApiKey,
   getGlobalConfig
-} from "./chunk-TMIQYE2C.js";
+} from "./chunk-JGJCX75W.js";
 import {
   debug,
   getCurrentRequest,
@@ -42,16 +42,16 @@ import {
   logLLMInteraction,
   logSystemPromptConstruction,
   markPhase
-} from "./chunk-PYRG5FKD.js";
+} from "./chunk-SYHWDS75.js";
 import {
   PRODUCT_COMMAND,
   env,
   getCwd,
   logError
-} from "./chunk-Q653YYZS.js";
+} from "./chunk-L62UDJSU.js";
 import {
   MACRO
-} from "./chunk-R56S2D3A.js";
+} from "./chunk-3BP3TGGN.js";
 import {
   addToTotalCost
 } from "./chunk-OUXHGDLH.js";
@@ -2821,7 +2821,7 @@ async function queryOpenAI(messages, systemPrompt, maxThinkingTokens, tools, sig
         start = Date.now();
         if (adapterContext) {
           if (adapterContext.shouldUseResponses) {
-            const { callGPT5ResponsesAPI } = await import("./openai-LIOQRL5O.js");
+            const { callGPT5ResponsesAPI } = await import("./openai-IW2EECJN.js");
             const response = await callGPT5ResponsesAPI(
               modelProfile,
               adapterContext.request,

package/dist/{chunk-65MNQP3U.js → chunk-FOQKIQ27.js}

@@ -4,10 +4,10 @@ import {
   PRODUCT_NAME,
   execFileNoThrow,
   logError
-} from "./chunk-Q653YYZS.js";
+} from "./chunk-L62UDJSU.js";
 import {
   MACRO
-} from "./chunk-R56S2D3A.js";
+} from "./chunk-3BP3TGGN.js";
 
 // src/utils/session/autoUpdater.ts
 async function getSemver() {
@@ -82,7 +82,7 @@ async function checkAndNotifyUpdate() {
     const [
       { isAutoUpdaterDisabled, getGlobalConfig, saveGlobalConfig },
       { env }
-    ] = await Promise.all([import("./config-EVFJADC4.js"), import("./env-KJ3YKVKD.js")]);
+    ] = await Promise.all([import("./config-53WMBY35.js"), import("./env-7GAPXLOS.js")]);
     if (await isAutoUpdaterDisabled()) return;
     if (await env.getIsDocker()) return;
     if (!await env.hasInternetAccess()) return;

package/dist/chunk-HCPU4TQ6.js

@@ -0,0 +1,478 @@
+import { createRequire as __pybCreateRequire } from "node:module";
+const require = __pybCreateRequire(import.meta.url);
+import {
+  BunShell,
+  execFileNoThrow,
+  logError
+} from "./chunk-L62UDJSU.js";
+
+// src/utils/system/ripgrep.ts
+import { findActualExecutable } from "spawn-rx";
+import { memoize } from "lodash-es";
+import {
+  chmodSync,
+  closeSync,
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  openSync,
+  readdirSync,
+  rmSync,
+  writeFileSync
+} from "node:fs";
+import { execFile, spawn } from "child_process";
+import debug from "debug";
+import { quote } from "shell-quote";
+import { basename, isAbsolute, join, relative, sep } from "path";
+import envPaths from "env-paths";
+import { unzipSync } from "fflate";
+var d = debug("pyb:ripgrep");
+var DEFAULT_RIPGREP_VERSION = "14.1.1";
+var PLATFORM_CONFIG = {
+  "arm64-darwin": { platform: "aarch64-apple-darwin", extension: "tar.gz" },
+  "arm64-linux": { platform: "aarch64-unknown-linux-gnu", extension: "tar.gz" },
+  "x64-darwin": { platform: "x86_64-apple-darwin", extension: "tar.gz" },
+  "x64-linux": { platform: "x86_64-unknown-linux-musl", extension: "tar.gz" },
+  "x64-win32": { platform: "x86_64-pc-windows-msvc", extension: "zip" }
+};
+function isTruthyEnv(value) {
+  if (!value) return false;
+  return ["1", "true", "yes", "on"].includes(value.trim().toLowerCase());
+}
+function getRipgrepVersion() {
+  const override = process.env.PYB_RIPGREP_VERSION?.trim();
+  return override || DEFAULT_RIPGREP_VERSION;
+}
+function getRipgrepBinaryName() {
+  return process.platform === "win32" ? "rg.exe" : "rg";
+}
+function getPlatformConfig() {
+  const platformKey = `${process.arch}-${process.platform}`;
+  const config = PLATFORM_CONFIG[platformKey];
+  if (!config) {
+    throw new Error(`Unsupported ripgrep platform: ${platformKey}`);
+  }
+  return { platformKey, ...config };
+}
+function getRipgrepCacheRoot() {
+  const override = process.env.PYB_RIPGREP_CACHE_DIR?.trim();
+  if (override) return override;
+  const paths = envPaths("pyb");
+  return join(paths.cache, "ripgrep");
+}
+function getDownloadBaseUrl(version) {
+  const override = process.env.PYB_RIPGREP_DOWNLOAD_BASE_URL?.trim();
+  if (!override) {
+    return `https://github.com/BurntSushi/ripgrep/releases/download/${version}`;
+  }
+  if (override.includes("{version}")) {
+    return override.replace("{version}", version);
+  }
+  return `${override.replace(/\/$/, "")}/${version}`;
+}
+async function delay(ms) {
+  await new Promise((resolve) => setTimeout(resolve, ms));
+}
+function findFileRecursive(root, filename) {
+  const entries = readdirSync(root, { withFileTypes: true });
+  for (const entry of entries) {
+    const full = join(root, entry.name);
+    if (entry.isDirectory()) {
+      const found = findFileRecursive(full, filename);
+      if (found) return found;
+    } else if (entry.isFile() && entry.name === filename) {
+      return full;
+    }
+  }
+  return null;
+}
+async function execFileChecked(command, args, options) {
+  await new Promise((resolve, reject) => {
+    execFile(
+      command,
+      args,
+      { cwd: options.cwd, maxBuffer: 1e6 },
+      (error, _stdout, stderr) => {
+        if (error) {
+          reject(
+            new Error(
+              `${command} ${args.join(" ")} failed: ${stderr || error.message}`
+            )
+          );
+        } else {
+          resolve();
+        }
+      }
+    );
+  });
+}
+async function acquireLock(lockPath, readyPath) {
+  const start = Date.now();
+  while (true) {
+    try {
+      return openSync(lockPath, "wx");
+    } catch (error) {
+      if (error?.code !== "EEXIST") {
+        throw error;
+      }
+      if (existsSync(readyPath)) return null;
+      if (Date.now() - start > 2e4) {
+        throw new Error("Timed out waiting for ripgrep download lock");
+      }
+      await delay(100);
+    }
+  }
+}
+async function downloadRipgrepTo(cacheDir) {
+  const { platform, extension, platformKey } = getPlatformConfig();
+  const version = getRipgrepVersion();
+  const filename = `ripgrep-${version}-${platform}.${extension}`;
+  const url = `${getDownloadBaseUrl(version)}/${filename}`;
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(
+      `Failed to download ripgrep (${response.status}): ${url}`
+    );
+  }
+  const buffer = new Uint8Array(await response.arrayBuffer());
+  const tempDir = mkdtempSync(join(cacheDir, "tmp-"));
+  try {
+    const binaryName = getRipgrepBinaryName();
+    const targetPath = join(cacheDir, binaryName);
+    if (extension === "zip") {
+      const files = unzipSync(buffer);
+      const entryName = Object.keys(files).find(
+        (name) => name.endsWith(binaryName)
+      );
+      if (!entryName) {
+        throw new Error(`ripgrep binary not found in zip: ${filename}`);
+      }
+      writeFileSync(targetPath, files[entryName]);
+    } else {
+      const archivePath = join(tempDir, filename);
+      const extractDir = join(tempDir, "extract");
+      mkdirSync(extractDir, { recursive: true });
+      writeFileSync(archivePath, buffer);
+      await execFileChecked("tar", ["-xzf", archivePath, "-C", extractDir], {
+        cwd: tempDir
+      });
+      const extracted = findFileRecursive(extractDir, binaryName);
+      if (!extracted) {
+        throw new Error(
+          `ripgrep binary not found after extraction: ${platformKey}`
+        );
+      }
+      copyFileSync(extracted, targetPath);
+    }
+    if (process.platform !== "win32") {
+      chmodSync(targetPath, 493);
+    }
+    return targetPath;
+  } finally {
+    rmSync(tempDir, { recursive: true, force: true });
+  }
+}
+async function ensureCachedRipgrep() {
+  const version = getRipgrepVersion();
+  const { platformKey } = getPlatformConfig();
+  const cacheRoot = getRipgrepCacheRoot();
+  const cacheDir = join(cacheRoot, version, platformKey);
+  const binaryPath = join(cacheDir, getRipgrepBinaryName());
+  if (existsSync(binaryPath)) return binaryPath;
+  mkdirSync(cacheDir, { recursive: true });
+  const lockPath = join(cacheDir, ".lock");
+  const lockFd = await acquireLock(lockPath, binaryPath);
+  if (!lockFd) return binaryPath;
+  try {
+    if (!existsSync(binaryPath)) {
+      await downloadRipgrepTo(cacheDir);
+    }
+    return binaryPath;
+  } finally {
+    try {
+      closeSync(lockFd);
+    } catch {
+    }
+    rmSync(lockPath, { force: true });
+  }
+}
+async function resolveRipgrepPathOrThrow() {
+  const explicit = process.env.PYB_RIPGREP_PATH;
+  if (explicit) {
+    if (!existsSync(explicit)) {
+      throw new Error(`PYB_RIPGREP_PATH points to a missing file: ${explicit}`);
+    }
+    return explicit;
+  }
+  const preferBundled = isTruthyEnv(process.env.USE_BUILTIN_RIPGREP);
+  if (!preferBundled) {
+    const { cmd } = findActualExecutable("rg", []);
+    d(`ripgrep initially resolved as: ${cmd}`);
+    if (cmd !== "rg") {
+      return cmd;
+    }
+  }
+  const cached = await ensureCachedRipgrep();
+  d("Using cached ripgrep: %s", cached);
+  return cached;
+}
+var getRipgrepPath = memoize(
+  async () => resolveRipgrepPathOrThrow()
+);
+async function ripGrepWithStatus(args, target, abortSignal, options) {
+  await codesignRipgrepIfNecessary();
+  const rg = await getRipgrepPath();
+  d("ripgrep called: %s %o", rg, target, args);
+  if (options?.sandbox?.enabled === true) {
+    const cmd = quote([rg, ...args, target]);
+    const result = await BunShell.getInstance().exec(cmd, abortSignal, 1e4, {
+      sandbox: options.sandbox
+    });
+    if (result.code === 1) return { files: [], status: "ok", code: 1 };
+    if (result.code !== 0) {
+      logError(`ripgrep failed with exit code ${result.code}: ${result.stderr}`);
+      return { files: [], status: "error", code: result.code };
+    }
+    return {
+      files: result.stdout.trim().split("\n").filter(Boolean),
+      status: "ok",
+      code: 0
+    };
+  }
+  return new Promise((resolve) => {
+    const bun = globalThis.Bun;
+    if (bun?.spawn && typeof bun.spawn === "function") {
+      const files2 = [];
+      let buffer2 = "";
+      let stderr2 = "";
+      const decoder = new TextDecoder();
+      const proc2 = bun.spawn([rg, ...args, target], {
+        stdout: "pipe",
+        stderr: "pipe",
+        signal: abortSignal
+      });
+      const readStdout = async () => {
+        const reader = proc2.stdout.getReader();
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          buffer2 += decoder.decode(value, { stream: true });
+          const parts = buffer2.split(/\r?\n/);
+          buffer2 = parts.pop() ?? "";
+          for (const line of parts) {
+            if (line) files2.push(line);
+          }
+        }
+        reader.releaseLock();
+      };
+      const readStderr = async () => {
+        const reader = proc2.stderr.getReader();
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          stderr2 += decoder.decode(value, { stream: true });
+        }
+        reader.releaseLock();
+      };
+      Promise.all([readStdout(), readStderr(), proc2.exited]).then(([_, __, exitCode]) => {
+        if (buffer2) files2.push(buffer2);
+        if (exitCode && exitCode !== 1) {
+          if (stderr2) {
+            logError(`ripgrep failed with exit code ${exitCode}: ${stderr2}`);
+          }
+          resolve({ files: [], status: "error", code: exitCode });
+          return;
+        }
+        resolve({ files: files2, status: "ok", code: exitCode ?? 0 });
+      }).catch((error) => {
+        d("ripgrep error: %o", error);
+        logError(error);
+        resolve({ files: [], status: "error" });
+      });
+      return;
+    }
+    const proc = spawn(rg, [...args, target], {
+      signal: abortSignal,
+      timeout: 1e4
+    });
+    const files = [];
+    let buffer = "";
+    let stderr = "";
+    proc.stdout?.on("data", (chunk) => {
+      buffer += chunk.toString();
+      const parts = buffer.split(/\r?\n/);
+      buffer = parts.pop() ?? "";
+      for (const line of parts) {
+        if (line) files.push(line);
+      }
+    });
+    proc.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    proc.on("error", (error) => {
+      d("ripgrep error: %o", error);
+      logError(error);
+    });
+    proc.on("close", (code) => {
+      if (buffer.trim().length > 0) files.push(buffer.trim());
+      if (code && code !== 1) {
+        if (stderr) {
+          logError(`ripgrep failed with exit code ${code}: ${stderr}`);
+        }
+        resolve({ files: [], status: "error", code });
+        return;
+      }
+      resolve({
+        files,
+        status: "ok",
+        code: code ?? 0
+      });
+    });
+  });
+}
+async function ripGrep(args, target, abortSignal, options) {
+  const result = await ripGrepWithStatus(args, target, abortSignal, options);
+  return result.files;
+}
+async function listAllContentFiles(path, abortSignal, limit) {
+  try {
+    d("listAllContentFiles called: %s", path);
+    return (await ripGrep(["-l", ".", path], path, abortSignal)).slice(0, limit);
+  } catch (e) {
+    d("listAllContentFiles failed: %o", e);
+    logError(e);
+    return [];
+  }
+}
+var alreadyDoneSignCheck = false;
+async function codesignRipgrepIfNecessary() {
+  if (process.platform !== "darwin" || alreadyDoneSignCheck) {
+    return;
+  }
+  alreadyDoneSignCheck = true;
+  d("checking if ripgrep is already signed");
+  const lines = (await execFileNoThrow(
+    "codesign",
+    ["-vv", "-d", await getRipgrepPath()],
+    void 0,
+    void 0,
+    false
+  )).stdout.split("\n");
+  const needsSigned = lines.find((line) => line.includes("linker-signed"));
+  if (!needsSigned) {
+    d("seems to be already signed");
+    return;
+  }
+  try {
+    d("signing ripgrep");
+    const signResult = await execFileNoThrow("codesign", [
+      "--sign",
+      "-",
+      "--force",
+      "--preserve-metadata=entitlements,requirements,flags,runtime",
+      await getRipgrepPath()
+    ]);
+    if (signResult.code !== 0) {
+      d("failed to sign ripgrep: %o", signResult);
+      logError(
+        `Failed to sign ripgrep: ${signResult.stdout} ${signResult.stderr}`
+      );
+    }
+    d("removing quarantine");
+    const quarantineResult = await execFileNoThrow("xattr", [
+      "-d",
+      "com.apple.quarantine",
+      await getRipgrepPath()
+    ]);
+    if (quarantineResult.code !== 0) {
+      d("failed to remove quarantine: %o", quarantineResult);
+      logError(
+        `Failed to remove quarantine: ${quarantineResult.stdout} ${quarantineResult.stderr}`
+      );
+    }
+  } catch (e) {
+    d("failed during sign: %o", e);
+    logError(e);
+  }
+}
+function resetRipgrepPathCacheForTests() {
+  ;
+  getRipgrepPath.cache?.clear?.();
+  alreadyDoneSignCheck = false;
+}
+function filesToTree(files, cwd, limit = 50) {
+  if (files.length === 0) return "";
+  const relFiles = files.map((f) => {
+    if (isAbsolute(f)) return relative(cwd, f);
+    return f;
+  });
+  const treeRoot = {};
+  for (const f of relFiles) {
+    const parts = f.split(sep);
+    let cur = treeRoot;
+    for (const p of parts) {
+      if (!cur[p]) cur[p] = {};
+      cur = cur[p];
+    }
+  }
+  const visible = /* @__PURE__ */ new Set();
+  const queue = [treeRoot];
+  visible.add(treeRoot);
+  let visibleCount = 0;
+  while (queue.length > 0) {
+    const node = queue.shift();
+    const children = Object.values(node);
+    for (const child of children) {
+      if (visibleCount < limit) {
+        visible.add(child);
+        visibleCount++;
+        queue.push(child);
+      } else {
+        break;
+      }
+    }
+    if (visibleCount >= limit) break;
+  }
+  let output = "";
+  function render(node, prefix, isLast, name) {
+    if (node !== treeRoot) {
+      const connector = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+      output += `${prefix}${connector}${name}
+`;
+    } else {
+      output += `${name}
+`;
+    }
+    const childrenKeys = Object.keys(node).sort();
+    const visibleChildren = childrenKeys.filter((k) => visible.has(node[k]));
+    const hiddenCount = childrenKeys.length - visibleChildren.length;
+    const childPrefix = node === treeRoot ? "" : prefix + (isLast ? "    " : "\u2502   ");
+    for (let i = 0; i < visibleChildren.length; i++) {
+      const key = visibleChildren[i];
+      const isChildLast = i === visibleChildren.length - 1 && hiddenCount === 0;
+      render(node[key], childPrefix, isChildLast, key);
+    }
+    if (hiddenCount > 0) {
+      const connector = "\u2514\u2500\u2500 ";
+      output += `${childPrefix}${connector}... [${hiddenCount} truncated]
+`;
+    }
+  }
+  render(treeRoot, "", true, basename(cwd) || ".");
+  return output;
+}
+async function tree(cwd, limit = 50, abortSignal) {
+  const files = await ripGrep(["--files"], cwd, abortSignal);
+  return filesToTree(files, cwd, limit);
+}
+
+export {
+  getRipgrepPath,
+  ripGrepWithStatus,
+  ripGrep,
+  listAllContentFiles,
+  resetRipgrepPathCacheForTests,
+  filesToTree,
+  tree
+};