@morphllm/morphsdk 0.2.67 → 0.2.68

package/dist/tools/warp_grep/index.cjs

@@ -5,6 +5,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -27,6 +30,394 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// node_modules/ignore/index.js
+var require_ignore = __commonJS({
+  "node_modules/ignore/index.js"(exports2, module2) {
+    "use strict";
+    function makeArray(subject) {
+      return Array.isArray(subject) ? subject : [subject];
+    }
+    var EMPTY = "";
+    var SPACE = " ";
+    var ESCAPE = "\\";
+    var REGEX_TEST_BLANK_LINE = /^\s+$/;
+    var REGEX_INVALID_TRAILING_BACKSLASH = /(?:[^\\]|^)\\$/;
+    var REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\!/;
+    var REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\#/;
+    var REGEX_SPLITALL_CRLF = /\r?\n/g;
+    var REGEX_TEST_INVALID_PATH = /^\.*\/|^\.+$/;
+    var SLASH = "/";
+    var TMP_KEY_IGNORE = "node-ignore";
+    if (typeof Symbol !== "undefined") {
+      TMP_KEY_IGNORE = Symbol.for("node-ignore");
+    }
+    var KEY_IGNORE = TMP_KEY_IGNORE;
+    var define = (object, key, value) => Object.defineProperty(object, key, { value });
+    var REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g;
+    var RETURN_FALSE = () => false;
+    var sanitizeRange = (range) => range.replace(
+      REGEX_REGEXP_RANGE,
+      (match, from, to) => from.charCodeAt(0) <= to.charCodeAt(0) ? match : EMPTY
+    );
+    var cleanRangeBackSlash = (slashes) => {
+      const { length } = slashes;
+      return slashes.slice(0, length - length % 2);
+    };
+    var REPLACERS = [
+      [
+        // remove BOM
+        // TODO:
+        // Other similar zero-width characters?
+        /^\uFEFF/,
+        () => EMPTY
+      ],
+      // > Trailing spaces are ignored unless they are quoted with backslash ("\")
+      [
+        // (a\ ) -> (a )
+        // (a  ) -> (a)
+        // (a ) -> (a)
+        // (a \ ) -> (a  )
+        /((?:\\\\)*?)(\\?\s+)$/,
+        (_, m1, m2) => m1 + (m2.indexOf("\\") === 0 ? SPACE : EMPTY)
+      ],
+      // replace (\ ) with ' '
+      // (\ ) -> ' '
+      // (\\ ) -> '\\ '
+      // (\\\ ) -> '\\ '
+      [
+        /(\\+?)\s/g,
+        (_, m1) => {
+          const { length } = m1;
+          return m1.slice(0, length - length % 2) + SPACE;
+        }
+      ],
+      // Escape metacharacters
+      // which is written down by users but means special for regular expressions.
+      // > There are 12 characters with special meanings:
+      // > - the backslash \,
+      // > - the caret ^,
+      // > - the dollar sign $,
+      // > - the period or dot .,
+      // > - the vertical bar or pipe symbol |,
+      // > - the question mark ?,
+      // > - the asterisk or star *,
+      // > - the plus sign +,
+      // > - the opening parenthesis (,
+      // > - the closing parenthesis ),
+      // > - and the opening square bracket [,
+      // > - the opening curly brace {,
+      // > These special characters are often called "metacharacters".
+      [
+        /[\\$.|*+(){^]/g,
+        (match) => `\\${match}`
+      ],
+      [
+        // > a question mark (?) matches a single character
+        /(?!\\)\?/g,
+        () => "[^/]"
+      ],
+      // leading slash
+      [
+        // > A leading slash matches the beginning of the pathname.
+        // > For example, "/*.c" matches "cat-file.c" but not "mozilla-sha1/sha1.c".
+        // A leading slash matches the beginning of the pathname
+        /^\//,
+        () => "^"
+      ],
+      // replace special metacharacter slash after the leading slash
+      [
+        /\//g,
+        () => "\\/"
+      ],
+      [
+        // > A leading "**" followed by a slash means match in all directories.
+        // > For example, "**/foo" matches file or directory "foo" anywhere,
+        // > the same as pattern "foo".
+        // > "**/foo/bar" matches file or directory "bar" anywhere that is directly
+        // >   under directory "foo".
+        // Notice that the '*'s have been replaced as '\\*'
+        /^\^*\\\*\\\*\\\//,
+        // '**/foo' <-> 'foo'
+        () => "^(?:.*\\/)?"
+      ],
+      // starting
+      [
+        // there will be no leading '/'
+        //   (which has been replaced by section "leading slash")
+        // If starts with '**', adding a '^' to the regular expression also works
+        /^(?=[^^])/,
+        function startingReplacer() {
+          return !/\/(?!$)/.test(this) ? "(?:^|\\/)" : "^";
+        }
+      ],
+      // two globstars
+      [
+        // Use lookahead assertions so that we could match more than one `'/**'`
+        /\\\/\\\*\\\*(?=\\\/|$)/g,
+        // Zero, one or several directories
+        // should not use '*', or it will be replaced by the next replacer
+        // Check if it is not the last `'/**'`
+        (_, index, str) => index + 6 < str.length ? "(?:\\/[^\\/]+)*" : "\\/.+"
+      ],
+      // normal intermediate wildcards
+      [
+        // Never replace escaped '*'
+        // ignore rule '\*' will match the path '*'
+        // 'abc.*/' -> go
+        // 'abc.*'  -> skip this rule,
+        //    coz trailing single wildcard will be handed by [trailing wildcard]
+        /(^|[^\\]+)(\\\*)+(?=.+)/g,
+        // '*.js' matches '.js'
+        // '*.js' doesn't match 'abc'
+        (_, p1, p2) => {
+          const unescaped = p2.replace(/\\\*/g, "[^\\/]*");
+          return p1 + unescaped;
+        }
+      ],
+      [
+        // unescape, revert step 3 except for back slash
+        // For example, if a user escape a '\\*',
+        // after step 3, the result will be '\\\\\\*'
+        /\\\\\\(?=[$.|*+(){^])/g,
+        () => ESCAPE
+      ],
+      [
+        // '\\\\' -> '\\'
+        /\\\\/g,
+        () => ESCAPE
+      ],
+      [
+        // > The range notation, e.g. [a-zA-Z],
+        // > can be used to match one of the characters in a range.
+        // `\` is escaped by step 3
+        /(\\)?\[([^\]/]*?)(\\*)($|\])/g,
+        (match, leadEscape, range, endEscape, close) => leadEscape === ESCAPE ? `\\[${range}${cleanRangeBackSlash(endEscape)}${close}` : close === "]" ? endEscape.length % 2 === 0 ? `[${sanitizeRange(range)}${endEscape}]` : "[]" : "[]"
+      ],
+      // ending
+      [
+        // 'js' will not match 'js.'
+        // 'ab' will not match 'abc'
+        /(?:[^*])$/,
+        // WTF!
+        // https://git-scm.com/docs/gitignore
+        // changes in [2.22.1](https://git-scm.com/docs/gitignore/2.22.1)
+        // which re-fixes #24, #38
+        // > If there is a separator at the end of the pattern then the pattern
+        // > will only match directories, otherwise the pattern can match both
+        // > files and directories.
+        // 'js*' will not match 'a.js'
+        // 'js/' will not match 'a.js'
+        // 'js' will match 'a.js' and 'a.js/'
+        (match) => /\/$/.test(match) ? `${match}$` : `${match}(?=$|\\/$)`
+      ],
+      // trailing wildcard
+      [
+        /(\^|\\\/)?\\\*$/,
+        (_, p1) => {
+          const prefix = p1 ? `${p1}[^/]+` : "[^/]*";
+          return `${prefix}(?=$|\\/$)`;
+        }
+      ]
+    ];
+    var regexCache = /* @__PURE__ */ Object.create(null);
+    var makeRegex = (pattern, ignoreCase) => {
+      let source = regexCache[pattern];
+      if (!source) {
+        source = REPLACERS.reduce(
+          (prev, [matcher, replacer]) => prev.replace(matcher, replacer.bind(pattern)),
+          pattern
+        );
+        regexCache[pattern] = source;
+      }
+      return ignoreCase ? new RegExp(source, "i") : new RegExp(source);
+    };
+    var isString = (subject) => typeof subject === "string";
+    var checkPattern = (pattern) => pattern && isString(pattern) && !REGEX_TEST_BLANK_LINE.test(pattern) && !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern) && pattern.indexOf("#") !== 0;
+    var splitPattern = (pattern) => pattern.split(REGEX_SPLITALL_CRLF);
+    var IgnoreRule = class {
+      constructor(origin, pattern, negative, regex) {
+        this.origin = origin;
+        this.pattern = pattern;
+        this.negative = negative;
+        this.regex = regex;
+      }
+    };
+    var createRule = (pattern, ignoreCase) => {
+      const origin = pattern;
+      let negative = false;
+      if (pattern.indexOf("!") === 0) {
+        negative = true;
+        pattern = pattern.substr(1);
+      }
+      pattern = pattern.replace(REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION, "!").replace(REGEX_REPLACE_LEADING_EXCAPED_HASH, "#");
+      const regex = makeRegex(pattern, ignoreCase);
+      return new IgnoreRule(
+        origin,
+        pattern,
+        negative,
+        regex
+      );
+    };
+    var throwError = (message, Ctor) => {
+      throw new Ctor(message);
+    };
+    var checkPath = (path5, originalPath, doThrow) => {
+      if (!isString(path5)) {
+        return doThrow(
+          `path must be a string, but got \`${originalPath}\``,
+          TypeError
+        );
+      }
+      if (!path5) {
+        return doThrow(`path must not be empty`, TypeError);
+      }
+      if (checkPath.isNotRelative(path5)) {
+        const r = "`path.relative()`d";
+        return doThrow(
+          `path should be a ${r} string, but got "${originalPath}"`,
+          RangeError
+        );
+      }
+      return true;
+    };
+    var isNotRelative = (path5) => REGEX_TEST_INVALID_PATH.test(path5);
+    checkPath.isNotRelative = isNotRelative;
+    checkPath.convert = (p) => p;
+    var Ignore = class {
+      constructor({
+        ignorecase = true,
+        ignoreCase = ignorecase,
+        allowRelativePaths = false
+      } = {}) {
+        define(this, KEY_IGNORE, true);
+        this._rules = [];
+        this._ignoreCase = ignoreCase;
+        this._allowRelativePaths = allowRelativePaths;
+        this._initCache();
+      }
+      _initCache() {
+        this._ignoreCache = /* @__PURE__ */ Object.create(null);
+        this._testCache = /* @__PURE__ */ Object.create(null);
+      }
+      _addPattern(pattern) {
+        if (pattern && pattern[KEY_IGNORE]) {
+          this._rules = this._rules.concat(pattern._rules);
+          this._added = true;
+          return;
+        }
+        if (checkPattern(pattern)) {
+          const rule = createRule(pattern, this._ignoreCase);
+          this._added = true;
+          this._rules.push(rule);
+        }
+      }
+      // @param {Array<string> | string | Ignore} pattern
+      add(pattern) {
+        this._added = false;
+        makeArray(
+          isString(pattern) ? splitPattern(pattern) : pattern
+        ).forEach(this._addPattern, this);
+        if (this._added) {
+          this._initCache();
+        }
+        return this;
+      }
+      // legacy
+      addPattern(pattern) {
+        return this.add(pattern);
+      }
+      //          |           ignored : unignored
+      // negative |   0:0   |   0:1   |   1:0   |   1:1
+      // -------- | ------- | ------- | ------- | --------
+      //     0    |  TEST   |  TEST   |  SKIP   |    X
+      //     1    |  TESTIF |  SKIP   |  TEST   |    X
+      // - SKIP: always skip
+      // - TEST: always test
+      // - TESTIF: only test if checkUnignored
+      // - X: that never happen
+      // @param {boolean} whether should check if the path is unignored,
+      //   setting `checkUnignored` to `false` could reduce additional
+      //   path matching.
+      // @returns {TestResult} true if a file is ignored
+      _testOne(path5, checkUnignored) {
+        let ignored = false;
+        let unignored = false;
+        this._rules.forEach((rule) => {
+          const { negative } = rule;
+          if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
+            return;
+          }
+          const matched = rule.regex.test(path5);
+          if (matched) {
+            ignored = !negative;
+            unignored = negative;
+          }
+        });
+        return {
+          ignored,
+          unignored
+        };
+      }
+      // @returns {TestResult}
+      _test(originalPath, cache, checkUnignored, slices) {
+        const path5 = originalPath && checkPath.convert(originalPath);
+        checkPath(
+          path5,
+          originalPath,
+          this._allowRelativePaths ? RETURN_FALSE : throwError
+        );
+        return this._t(path5, cache, checkUnignored, slices);
+      }
+      _t(path5, cache, checkUnignored, slices) {
+        if (path5 in cache) {
+          return cache[path5];
+        }
+        if (!slices) {
+          slices = path5.split(SLASH);
+        }
+        slices.pop();
+        if (!slices.length) {
+          return cache[path5] = this._testOne(path5, checkUnignored);
+        }
+        const parent = this._t(
+          slices.join(SLASH) + SLASH,
+          cache,
+          checkUnignored,
+          slices
+        );
+        return cache[path5] = parent.ignored ? parent : this._testOne(path5, checkUnignored);
+      }
+      ignores(path5) {
+        return this._test(path5, this._ignoreCache, false).ignored;
+      }
+      createFilter() {
+        return (path5) => !this.ignores(path5);
+      }
+      filter(paths) {
+        return makeArray(paths).filter(this.createFilter());
+      }
+      // @returns {TestResult}
+      test(path5) {
+        return this._test(path5, this._testCache, true);
+      }
+    };
+    var factory = (options) => new Ignore(options);
+    var isPathValid = (path5) => checkPath(path5 && checkPath.convert(path5), path5, RETURN_FALSE);
+    factory.isPathValid = isPathValid;
+    factory.default = factory;
+    module2.exports = factory;
+    if (
+      // Detect `process` so that it can run in browsers.
+      typeof process !== "undefined" && (process.env && process.env.IGNORE_TEST_WIN32 || process.platform === "win32")
+    ) {
+      const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
+      checkPath.convert = makePosix;
+      const REGIX_IS_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
+      checkPath.isNotRelative = (path5) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path5) || isNotRelative(path5);
+    }
+  }
+});
+
 // tools/warp_grep/index.ts
 var warp_grep_exports = {};
 __export(warp_grep_exports, {
@@ -1234,11 +1625,30 @@ async function readAllLines(filePath) {
 }
 
 // tools/warp_grep/providers/local.ts
+var ignore = require_ignore().default || require_ignore();
 var LocalRipgrepProvider = class {
   constructor(repoRoot, excludes = DEFAULT_EXCLUDES) {
     this.repoRoot = repoRoot;
     this.excludes = excludes;
   }
+  ignoreFilter = null;
+  /**
+   * Build an ignore filter that combines DEFAULT_EXCLUDES and .gitignore patterns.
+   * Cached after first call.
+   */
+  async getIgnoreFilter() {
+    if (this.ignoreFilter) return this.ignoreFilter;
+    const ig = ignore();
+    ig.add(this.excludes);
+    try {
+      const gitignorePath = import_path4.default.join(this.repoRoot, ".gitignore");
+      const gitignoreContent = await import_promises2.default.readFile(gitignorePath, "utf-8");
+      ig.add(gitignoreContent);
+    } catch {
+    }
+    this.ignoreFilter = ig;
+    return ig;
+  }
   async grep(params) {
     let abs;
     try {
@@ -1366,9 +1776,11 @@ Details: ${res.stderr}` : ""}`
     const maxResults = params.maxResults ?? AGENT_CONFIG.MAX_OUTPUT_LINES;
     const maxDepth = params.maxDepth ?? AGENT_CONFIG.MAX_LIST_DEPTH;
     const regex = params.pattern ? new RegExp(params.pattern) : null;
+    const ig = await this.getIgnoreFilter();
     const results = [];
     let timedOut = false;
     const startTime = Date.now();
+    const repoRoot = this.repoRoot;
     async function walk(dir, depth) {
       if (Date.now() - startTime > AGENT_CONFIG.LIST_TIMEOUT_MS) {
         timedOut = true;
@@ -1379,17 +1791,18 @@ Details: ${res.stderr}` : ""}`
       for (const entry of entries) {
         if (timedOut || results.length >= maxResults) break;
         const full = import_path4.default.join(dir, entry.name);
-        const rel = toRepoRelative(abs, full).replace(/^[.][/\\]?/, "");
-        if (DEFAULT_EXCLUDES.some((ex) => rel.split(import_path4.default.sep).includes(ex))) continue;
+        const relToRepo = toRepoRelative(repoRoot, full).replace(/^[.][/\\]?/, "");
+        const isDir = entry.isDirectory();
+        if (ig.ignores(relToRepo) || isDir && ig.ignores(relToRepo + "/")) continue;
         if (regex && !regex.test(entry.name)) continue;
         results.push({
           name: entry.name,
           path: toRepoRelative(import_path4.default.resolve(""), full),
           // relative display
-          type: entry.isDirectory() ? "dir" : "file",
+          type: isDir ? "dir" : "file",
           depth
         });
-        if (entry.isDirectory()) {
+        if (isDir) {
           await walk(full, depth + 1);
         }
       }
@@ -1400,11 +1813,25 @@ Details: ${res.stderr}` : ""}`
 };
 
 // tools/warp_grep/providers/remote.ts
+var ignore2 = require_ignore().default || require_ignore();
 var RemoteCommandsProvider = class {
   constructor(repoRoot, commands) {
     this.repoRoot = repoRoot;
     this.commands = commands;
   }
+  ignoreFilter = null;
+  /**
+   * Build an ignore filter from DEFAULT_EXCLUDES.
+   * Note: For remote providers, we can't read .gitignore from the remote sandbox,
+   * so we only use the built-in excludes.
+   */
+  getIgnoreFilter() {
+    if (this.ignoreFilter) return this.ignoreFilter;
+    const ig = ignore2();
+    ig.add(DEFAULT_EXCLUDES);
+    this.ignoreFilter = ig;
+    return ig;
+  }
   /**
    * Run grep command and parse ripgrep output
    */
@@ -1458,6 +1885,7 @@ var RemoteCommandsProvider = class {
   async listDirectory(params) {
     const maxDepth = params.maxDepth ?? AGENT_CONFIG.MAX_LIST_DEPTH;
     const maxResults = params.maxResults ?? AGENT_CONFIG.MAX_OUTPUT_LINES;
+    const ig = this.getIgnoreFilter();
     try {
       const stdout = await this.commands.listDir(params.path, maxDepth);
       const paths = (stdout || "").trim().split(/\r?\n/).filter((p) => p.length > 0);
@@ -1466,11 +1894,12 @@ var RemoteCommandsProvider = class {
       for (const fullPath of paths) {
         if (fullPath === params.path || fullPath === this.repoRoot) continue;
         const name = fullPath.split("/").pop() || "";
-        if (regex && !regex.test(name)) continue;
         let relativePath = fullPath;
         if (fullPath.startsWith(this.repoRoot)) {
           relativePath = fullPath.slice(this.repoRoot.length).replace(/^\//, "");
         }
+        if (ig.ignores(relativePath)) continue;
+        if (regex && !regex.test(name)) continue;
         const depth = relativePath.split("/").filter(Boolean).length - 1;
         const hasExtension = name.includes(".") && !name.startsWith(".");
         const type = hasExtension ? "file" : "dir";