@zyycn/claudex 1.0.3-fork.2a74621

package/dist/chunk-v78fj8by.js

@@ -0,0 +1,145 @@
+// @bun
+import {
+  require_color_convert
+} from "./chunk-sd36yzx8.js";
+import {
+  __commonJS
+} from "./chunk-qp2qdcda.js";
+
+// node_modules/.bun/ansi-styles@4.3.0/node_modules/ansi-styles/index.js
+var require_ansi_styles = __commonJS((exports, module) => {
+  var wrapAnsi16 = (fn, offset) => (...args) => {
+    const code = fn(...args);
+    return `\x1B[${code + offset}m`;
+  };
+  var wrapAnsi256 = (fn, offset) => (...args) => {
+    const code = fn(...args);
+    return `\x1B[${38 + offset};5;${code}m`;
+  };
+  var wrapAnsi16m = (fn, offset) => (...args) => {
+    const rgb = fn(...args);
+    return `\x1B[${38 + offset};2;${rgb[0]};${rgb[1]};${rgb[2]}m`;
+  };
+  var ansi2ansi = (n) => n;
+  var rgb2rgb = (r, g, b) => [r, g, b];
+  var setLazyProperty = (object, property, get) => {
+    Object.defineProperty(object, property, {
+      get: () => {
+        const value = get();
+        Object.defineProperty(object, property, {
+          value,
+          enumerable: true,
+          configurable: true
+        });
+        return value;
+      },
+      enumerable: true,
+      configurable: true
+    });
+  };
+  var colorConvert;
+  var makeDynamicStyles = (wrap, targetSpace, identity, isBackground) => {
+    if (colorConvert === undefined) {
+      colorConvert = require_color_convert();
+    }
+    const offset = isBackground ? 10 : 0;
+    const styles = {};
+    for (const [sourceSpace, suite] of Object.entries(colorConvert)) {
+      const name = sourceSpace === "ansi16" ? "ansi" : sourceSpace;
+      if (sourceSpace === targetSpace) {
+        styles[name] = wrap(identity, offset);
+      } else if (typeof suite === "object") {
+        styles[name] = wrap(suite[targetSpace], offset);
+      }
+    }
+    return styles;
+  };
+  function assembleStyles() {
+    const codes = new Map;
+    const styles = {
+      modifier: {
+        reset: [0, 0],
+        bold: [1, 22],
+        dim: [2, 22],
+        italic: [3, 23],
+        underline: [4, 24],
+        inverse: [7, 27],
+        hidden: [8, 28],
+        strikethrough: [9, 29]
+      },
+      color: {
+        black: [30, 39],
+        red: [31, 39],
+        green: [32, 39],
+        yellow: [33, 39],
+        blue: [34, 39],
+        magenta: [35, 39],
+        cyan: [36, 39],
+        white: [37, 39],
+        blackBright: [90, 39],
+        redBright: [91, 39],
+        greenBright: [92, 39],
+        yellowBright: [93, 39],
+        blueBright: [94, 39],
+        magentaBright: [95, 39],
+        cyanBright: [96, 39],
+        whiteBright: [97, 39]
+      },
+      bgColor: {
+        bgBlack: [40, 49],
+        bgRed: [41, 49],
+        bgGreen: [42, 49],
+        bgYellow: [43, 49],
+        bgBlue: [44, 49],
+        bgMagenta: [45, 49],
+        bgCyan: [46, 49],
+        bgWhite: [47, 49],
+        bgBlackBright: [100, 49],
+        bgRedBright: [101, 49],
+        bgGreenBright: [102, 49],
+        bgYellowBright: [103, 49],
+        bgBlueBright: [104, 49],
+        bgMagentaBright: [105, 49],
+        bgCyanBright: [106, 49],
+        bgWhiteBright: [107, 49]
+      }
+    };
+    styles.color.gray = styles.color.blackBright;
+    styles.bgColor.bgGray = styles.bgColor.bgBlackBright;
+    styles.color.grey = styles.color.blackBright;
+    styles.bgColor.bgGrey = styles.bgColor.bgBlackBright;
+    for (const [groupName, group] of Object.entries(styles)) {
+      for (const [styleName, style] of Object.entries(group)) {
+        styles[styleName] = {
+          open: `\x1B[${style[0]}m`,
+          close: `\x1B[${style[1]}m`
+        };
+        group[styleName] = styles[styleName];
+        codes.set(style[0], style[1]);
+      }
+      Object.defineProperty(styles, groupName, {
+        value: group,
+        enumerable: false
+      });
+    }
+    Object.defineProperty(styles, "codes", {
+      value: codes,
+      enumerable: false
+    });
+    styles.color.close = "\x1B[39m";
+    styles.bgColor.close = "\x1B[49m";
+    setLazyProperty(styles.color, "ansi", () => makeDynamicStyles(wrapAnsi16, "ansi16", ansi2ansi, false));
+    setLazyProperty(styles.color, "ansi256", () => makeDynamicStyles(wrapAnsi256, "ansi256", ansi2ansi, false));
+    setLazyProperty(styles.color, "ansi16m", () => makeDynamicStyles(wrapAnsi16m, "rgb", rgb2rgb, false));
+    setLazyProperty(styles.bgColor, "ansi", () => makeDynamicStyles(wrapAnsi16, "ansi16", ansi2ansi, true));
+    setLazyProperty(styles.bgColor, "ansi256", () => makeDynamicStyles(wrapAnsi256, "ansi256", ansi2ansi, true));
+    setLazyProperty(styles.bgColor, "ansi16m", () => makeDynamicStyles(wrapAnsi16m, "rgb", rgb2rgb, true));
+    return styles;
+  }
+  Object.defineProperty(module, "exports", {
+    enumerable: true,
+    get: assembleStyles
+  });
+});
+
+export { require_ansi_styles };

package/dist/chunk-v90xv5n9.js

@@ -0,0 +1,157 @@
+// @bun
+import {
+  expandPath,
+  init_path
+} from "./chunk-xq4cfvpn.js";
+import {
+  L,
+  init_index_min
+} from "./chunk-qnfx3qtx.js";
+import {
+  init_log,
+  logError
+} from "./chunk-yysj6sxt.js";
+import {
+  getCwd,
+  init_cwd
+} from "./chunk-8bedvdm1.js";
+import {
+  getFsImplementation,
+  init_fsOperations
+} from "./chunk-sbbj6ta3.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 };