@foxclicom/foxcli 2.1.89

package/dist/chunk-w34c4pn6.js

@@ -0,0 +1,417 @@
+// @bun
+import {
+  init_sideQuestion,
+  runSideQuestion
+} from "./chunk-tgvzn3q1.js";
+import {
+  ScrollBox_default,
+  init_ScrollBox
+} from "./chunk-04he5cyw.js";
+import {
+  Markdown,
+  SpinnerGlyph,
+  asSystemPrompt,
+  createAbortController,
+  getLastCacheSafeParams,
+  getMessagesAfterCompactBoundary,
+  getSystemContext,
+  getSystemPrompt,
+  getUserContext,
+  init_Markdown,
+  init_SpinnerGlyph,
+  init_abortController,
+  init_context,
+  init_forkedAgent,
+  init_messages1 as init_messages,
+  init_prompts1 as init_prompts,
+  init_systemPromptType
+} from "./chunk-363p49h1.js";
+import"./chunk-14cmss9n.js";
+import"./chunk-t0rgmccj.js";
+import"./chunk-2n877dxb.js";
+import"./chunk-cc15x0zt.js";
+import"./chunk-7ke2txc2.js";
+import"./chunk-t0zcygwt.js";
+import"./chunk-dmqarh6q.js";
+import"./chunk-ehtwnxpg.js";
+import"./chunk-3be7ka25.js";
+import"./chunk-nymbd7tw.js";
+import"./chunk-2gzv8nrw.js";
+import"./chunk-45kxdsp8.js";
+import"./chunk-cgfdkzhb.js";
+import"./chunk-5ctt9z6m.js";
+import"./chunk-z9w0ffmw.js";
+import"./chunk-9gbamk79.js";
+import"./chunk-4cptw4qa.js";
+import"./chunk-hfzj1m07.js";
+import {
+  init_modalContext,
+  init_useTerminalSize,
+  useModalOrTerminalSize,
+  useTerminalSize
+} from "./chunk-jxgm95zx.js";
+import {
+  ThemedBox_default,
+  ThemedText,
+  init_dist,
+  init_ink,
+  require_compiler_runtime,
+  useInterval
+} from "./chunk-nswqqqdd.js";
+import"./chunk-7m2nd8da.js";
+import"./chunk-ps49ymvj.js";
+import {
+  require_jsx_dev_runtime,
+  require_react
+} from "./chunk-g338npwr.js";
+import"./chunk-pxjqgrdk.js";
+import"./chunk-zk2wsm7d.js";
+import"./chunk-7wj3b774.js";
+import"./chunk-m06q12hg.js";
+import"./chunk-w9k8zntt.js";
+import {
+  DOWN_ARROW,
+  UP_ARROW,
+  init_config1 as init_config,
+  init_figures,
+  saveGlobalConfig
+} from "./chunk-skctedsv.js";
+import"./chunk-e3g8q4cn.js";
+import"./chunk-ctw5jwcd.js";
+import"./chunk-vratq94g.js";
+import"./chunk-rvqtbt9h.js";
+import"./chunk-0e1xsncc.js";
+import"./chunk-g0j0t6qk.js";
+import"./chunk-3c25bcsw.js";
+import"./chunk-tjaqa99q.js";
+import"./chunk-55wgxwa9.js";
+import"./chunk-spqaamnc.js";
+import"./chunk-4jm600zv.js";
+import"./chunk-w2z5pqd3.js";
+import"./chunk-7ymfj7m3.js";
+import"./chunk-f5ma3nh5.js";
+import"./chunk-qz2x630m.js";
+import"./chunk-cvge4pvp.js";
+import"./chunk-p2816w9z.js";
+import"./chunk-v9smspw2.js";
+import"./chunk-v1kzp02e.js";
+import"./chunk-0vkfrmqm.js";
+import"./chunk-0xjaqda8.js";
+import"./chunk-x14dq3v1.js";
+import"./chunk-cdz5yb0r.js";
+import"./chunk-h0rbjg6x.js";
+import"./chunk-7z8j9qfn.js";
+import"./chunk-hrzerbfw.js";
+import"./chunk-d18z9pna.js";
+import"./chunk-qnfx3qtx.js";
+import"./chunk-hjhc4cpt.js";
+import"./chunk-vyc0rjyx.js";
+import"./chunk-hx2tr4ep.js";
+import"./chunk-p7g7pf3f.js";
+import"./chunk-8tnsngw2.js";
+import"./chunk-8bedvdm1.js";
+import"./chunk-7wm5s02e.js";
+import {
+  errorMessage,
+  init_errors
+} from "./chunk-nxsh6de2.js";
+import"./chunk-fbv4apne.js";
+import"./chunk-3r24h7t6.js";
+import"./chunk-qqfa0dqg.js";
+import"./chunk-hqmz36b3.js";
+import"./chunk-4g3v8y12.js";
+import"./chunk-7739pg2c.js";
+import"./chunk-xszk7n10.js";
+import"./chunk-sdj9b9wh.js";
+import {
+  __esm,
+  __toESM
+} from "./chunk-qp2qdcda.js";
+
+// src/commands/btw/btw.tsx
+function BtwSideQuestion(t0) {
+  const $ = import_compiler_runtime.c(25);
+  const {
+    question,
+    context,
+    onDone
+  } = t0;
+  const [response, setResponse] = import_react.useState(null);
+  const [error, setError] = import_react.useState(null);
+  const [frame, setFrame] = import_react.useState(0);
+  const scrollRef = import_react.useRef(null);
+  const {
+    rows
+  } = useModalOrTerminalSize(useTerminalSize());
+  let t1;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t1 = () => setFrame(_temp);
+    $[0] = t1;
+  } else {
+    t1 = $[0];
+  }
+  useInterval(t1, response || error ? null : 80);
+  let t2;
+  if ($[1] !== onDone) {
+    t2 = function handleKeyDown2(e) {
+      if (e.key === "escape" || e.key === "return" || e.key === " " || e.ctrl && (e.key === "c" || e.key === "d")) {
+        e.preventDefault();
+        onDone(undefined, {
+          display: "skip"
+        });
+        return;
+      }
+      if (e.key === "up" || e.ctrl && e.key === "p") {
+        e.preventDefault();
+        scrollRef.current?.scrollBy(-SCROLL_LINES);
+      }
+      if (e.key === "down" || e.ctrl && e.key === "n") {
+        e.preventDefault();
+        scrollRef.current?.scrollBy(SCROLL_LINES);
+      }
+    };
+    $[1] = onDone;
+    $[2] = t2;
+  } else {
+    t2 = $[2];
+  }
+  const handleKeyDown = t2;
+  let t3;
+  let t4;
+  if ($[3] !== context || $[4] !== question) {
+    t3 = () => {
+      const abortController = createAbortController();
+      const fetchResponse = async function fetchResponse2() {
+        try {
+          const cacheSafeParams = await buildCacheSafeParams(context);
+          const result = await runSideQuestion({
+            question,
+            cacheSafeParams
+          });
+          if (!abortController.signal.aborted) {
+            if (result.response) {
+              setResponse(result.response);
+            } else {
+              setError("No response received");
+            }
+          }
+        } catch (t52) {
+          const err = t52;
+          if (!abortController.signal.aborted) {
+            setError(errorMessage(err) || "Failed to get response");
+          }
+        }
+      };
+      fetchResponse();
+      return () => {
+        abortController.abort();
+      };
+    };
+    t4 = [question, context];
+    $[3] = context;
+    $[4] = question;
+    $[5] = t3;
+    $[6] = t4;
+  } else {
+    t3 = $[5];
+    t4 = $[6];
+  }
+  import_react.useEffect(t3, t4);
+  const maxContentHeight = Math.max(5, rows - CHROME_ROWS - OUTER_CHROME_ROWS);
+  let t5;
+  if ($[7] === Symbol.for("react.memo_cache_sentinel")) {
+    t5 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+      color: "warning",
+      bold: true,
+      children: [
+        "/btw",
+        " "
+      ]
+    }, undefined, true, undefined, this);
+    $[7] = t5;
+  } else {
+    t5 = $[7];
+  }
+  let t6;
+  if ($[8] !== question) {
+    t6 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedBox_default, {
+      children: [
+        t5,
+        /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+          dimColor: true,
+          children: question
+        }, undefined, false, undefined, this)
+      ]
+    }, undefined, true, undefined, this);
+    $[8] = question;
+    $[9] = t6;
+  } else {
+    t6 = $[9];
+  }
+  let t7;
+  if ($[10] !== error || $[11] !== frame || $[12] !== response) {
+    t7 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ScrollBox_default, {
+      ref: scrollRef,
+      flexDirection: "column",
+      flexGrow: 1,
+      children: error ? /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+        color: "error",
+        children: error
+      }, undefined, false, undefined, this) : response ? /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Markdown, {
+        children: response
+      }, undefined, false, undefined, this) : /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedBox_default, {
+        children: [
+          /* @__PURE__ */ jsx_dev_runtime.jsxDEV(SpinnerGlyph, {
+            frame,
+            messageColor: "warning"
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+            color: "warning",
+            children: "Answering..."
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this)
+    }, undefined, false, undefined, this);
+    $[10] = error;
+    $[11] = frame;
+    $[12] = response;
+    $[13] = t7;
+  } else {
+    t7 = $[13];
+  }
+  let t8;
+  if ($[14] !== maxContentHeight || $[15] !== t7) {
+    t8 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedBox_default, {
+      marginTop: 1,
+      marginLeft: 2,
+      maxHeight: maxContentHeight,
+      children: t7
+    }, undefined, false, undefined, this);
+    $[14] = maxContentHeight;
+    $[15] = t7;
+    $[16] = t8;
+  } else {
+    t8 = $[16];
+  }
+  let t9;
+  if ($[17] !== error || $[18] !== response) {
+    t9 = (response || error) && /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedBox_default, {
+      marginTop: 1,
+      children: /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+        dimColor: true,
+        children: [
+          UP_ARROW,
+          "/",
+          DOWN_ARROW,
+          " to scroll \xB7 Space, Enter, or Escape to dismiss"
+        ]
+      }, undefined, true, undefined, this)
+    }, undefined, false, undefined, this);
+    $[17] = error;
+    $[18] = response;
+    $[19] = t9;
+  } else {
+    t9 = $[19];
+  }
+  let t10;
+  if ($[20] !== handleKeyDown || $[21] !== t6 || $[22] !== t8 || $[23] !== t9) {
+    t10 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedBox_default, {
+      flexDirection: "column",
+      paddingLeft: 2,
+      marginTop: 1,
+      tabIndex: 0,
+      autoFocus: true,
+      onKeyDown: handleKeyDown,
+      children: [
+        t6,
+        t8,
+        t9
+      ]
+    }, undefined, true, undefined, this);
+    $[20] = handleKeyDown;
+    $[21] = t6;
+    $[22] = t8;
+    $[23] = t9;
+    $[24] = t10;
+  } else {
+    t10 = $[24];
+  }
+  return t10;
+}
+function _temp(f) {
+  return f + 1;
+}
+function stripInProgressAssistantMessage(messages) {
+  const last = messages.at(-1);
+  if (last?.type === "assistant" && last.message.stop_reason === null) {
+    return messages.slice(0, -1);
+  }
+  return messages;
+}
+async function buildCacheSafeParams(context) {
+  const forkContextMessages = getMessagesAfterCompactBoundary(stripInProgressAssistantMessage(context.messages));
+  const saved = getLastCacheSafeParams();
+  if (saved) {
+    return {
+      systemPrompt: saved.systemPrompt,
+      userContext: saved.userContext,
+      systemContext: saved.systemContext,
+      toolUseContext: context,
+      forkContextMessages
+    };
+  }
+  const [rawSystemPrompt, userContext, systemContext] = await Promise.all([getSystemPrompt(context.options.tools, context.options.mainLoopModel, [], context.options.mcpClients), getUserContext(), getSystemContext()]);
+  return {
+    systemPrompt: asSystemPrompt(rawSystemPrompt),
+    userContext,
+    systemContext,
+    toolUseContext: context,
+    forkContextMessages
+  };
+}
+async function call(onDone, context, args) {
+  const question = args?.trim();
+  if (!question) {
+    onDone("Usage: /btw <your question>", {
+      display: "system"
+    });
+    return null;
+  }
+  saveGlobalConfig((current) => ({
+    ...current,
+    btwUseCount: current.btwUseCount + 1
+  }));
+  return /* @__PURE__ */ jsx_dev_runtime.jsxDEV(BtwSideQuestion, {
+    question,
+    context,
+    onDone
+  }, undefined, false, undefined, this);
+}
+var import_compiler_runtime, import_react, jsx_dev_runtime, CHROME_ROWS = 5, OUTER_CHROME_ROWS = 6, SCROLL_LINES = 3;
+var init_btw = __esm(() => {
+  init_dist();
+  init_Markdown();
+  init_SpinnerGlyph();
+  init_figures();
+  init_prompts();
+  init_modalContext();
+  init_context();
+  init_useTerminalSize();
+  init_ScrollBox();
+  init_ink();
+  init_abortController();
+  init_config();
+  init_errors();
+  init_forkedAgent();
+  init_messages();
+  init_sideQuestion();
+  init_systemPromptType();
+  import_compiler_runtime = __toESM(require_compiler_runtime(), 1);
+  import_react = __toESM(require_react(), 1);
+  jsx_dev_runtime = __toESM(require_jsx_dev_runtime(), 1);
+});
+init_btw();
+
+export {
+  call
+};

package/dist/chunk-w7wgpqcp.js

@@ -0,0 +1,157 @@
+// @bun
+import {
+  expandPath,
+  init_path
+} from "./chunk-ctw5jwcd.js";
+import {
+  L,
+  init_index_min
+} from "./chunk-qnfx3qtx.js";
+import {
+  init_log,
+  logError
+} from "./chunk-p7g7pf3f.js";
+import {
+  getCwd,
+  init_cwd
+} from "./chunk-8bedvdm1.js";
+import {
+  getFsImplementation,
+  init_fsOperations
+} from "./chunk-nxsh6de2.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/suggestions/directoryCompletion.ts
+import { basename, dirname, join, sep } from "path";
+function parsePartialPath(partialPath, basePath) {
+  if (!partialPath) {
+    const directory2 = basePath || getCwd();
+    return { directory: directory2, prefix: "" };
+  }
+  const resolved = expandPath(partialPath, basePath);
+  if (partialPath.endsWith("/") || partialPath.endsWith(sep)) {
+    return { directory: resolved, prefix: "" };
+  }
+  const directory = dirname(resolved);
+  const prefix = basename(partialPath);
+  return { directory, prefix };
+}
+async function scanDirectory(dirPath) {
+  const cached = directoryCache.get(dirPath);
+  if (cached) {
+    return cached;
+  }
+  try {
+    const fs = getFsImplementation();
+    const entries = await fs.readdir(dirPath);
+    const directories = entries.filter((entry) => entry.isDirectory() && !entry.name.startsWith(".")).map((entry) => ({
+      name: entry.name,
+      path: join(dirPath, entry.name),
+      type: "directory"
+    })).slice(0, 100);
+    directoryCache.set(dirPath, directories);
+    return directories;
+  } catch (error) {
+    logError(error);
+    return [];
+  }
+}
+async function getDirectoryCompletions(partialPath, options = {}) {
+  const { basePath = getCwd(), maxResults = 10 } = options;
+  const { directory, prefix } = parsePartialPath(partialPath, basePath);
+  const entries = await scanDirectory(directory);
+  const prefixLower = prefix.toLowerCase();
+  const matches = entries.filter((entry) => entry.name.toLowerCase().startsWith(prefixLower)).slice(0, maxResults);
+  return matches.map((entry) => ({
+    id: entry.path,
+    displayText: entry.name + "/",
+    description: "directory",
+    metadata: { type: "directory" }
+  }));
+}
+function isPathLikeToken(token) {
+  return token.startsWith("~/") || token.startsWith("/") || token.startsWith("./") || token.startsWith("../") || token === "~" || token === "." || token === "..";
+}
+async function scanDirectoryForPaths(dirPath, includeHidden = false) {
+  const cacheKey = `${dirPath}:${includeHidden}`;
+  const cached = pathCache.get(cacheKey);
+  if (cached) {
+    return cached;
+  }
+  try {
+    const fs = getFsImplementation();
+    const entries = await fs.readdir(dirPath);
+    const paths = entries.filter((entry) => includeHidden || !entry.name.startsWith(".")).map((entry) => ({
+      name: entry.name,
+      path: join(dirPath, entry.name),
+      type: entry.isDirectory() ? "directory" : "file"
+    })).sort((a, b) => {
+      if (a.type === "directory" && b.type !== "directory")
+        return -1;
+      if (a.type !== "directory" && b.type === "directory")
+        return 1;
+      return a.name.localeCompare(b.name);
+    }).slice(0, 100);
+    pathCache.set(cacheKey, paths);
+    return paths;
+  } catch (error) {
+    logError(error);
+    return [];
+  }
+}
+async function getPathCompletions(partialPath, options = {}) {
+  const {
+    basePath = getCwd(),
+    maxResults = 10,
+    includeFiles = true,
+    includeHidden = false
+  } = options;
+  const { directory, prefix } = parsePartialPath(partialPath, basePath);
+  const entries = await scanDirectoryForPaths(directory, includeHidden);
+  const prefixLower = prefix.toLowerCase();
+  const matches = entries.filter((entry) => {
+    if (!includeFiles && entry.type === "file")
+      return false;
+    return entry.name.toLowerCase().startsWith(prefixLower);
+  }).slice(0, maxResults);
+  const hasSeparator = partialPath.includes("/") || partialPath.includes(sep);
+  let dirPortion = "";
+  if (hasSeparator) {
+    const lastSlash = partialPath.lastIndexOf("/");
+    const lastSep = partialPath.lastIndexOf(sep);
+    const lastSeparatorPos = Math.max(lastSlash, lastSep);
+    dirPortion = partialPath.substring(0, lastSeparatorPos + 1);
+  }
+  if (dirPortion.startsWith("./") || dirPortion.startsWith("." + sep)) {
+    dirPortion = dirPortion.slice(2);
+  }
+  return matches.map((entry) => {
+    const fullPath = dirPortion + entry.name;
+    return {
+      id: fullPath,
+      displayText: entry.type === "directory" ? fullPath + "/" : fullPath,
+      metadata: { type: entry.type }
+    };
+  });
+}
+var CACHE_SIZE = 500, CACHE_TTL, directoryCache, pathCache;
+var init_directoryCompletion = __esm(() => {
+  init_index_min();
+  init_cwd();
+  init_fsOperations();
+  init_log();
+  init_path();
+  CACHE_TTL = 5 * 60 * 1000;
+  directoryCache = new L({
+    max: CACHE_SIZE,
+    ttl: CACHE_TTL
+  });
+  pathCache = new L({
+    max: CACHE_SIZE,
+    ttl: CACHE_TTL
+  });
+});
+
+export { getDirectoryCompletions, isPathLikeToken, getPathCompletions, init_directoryCompletion };