@kevisual/router 0.0.55 → 0.0.57

package/dist/opencode.js

@@ -0,0 +1,969 @@
+// src/utils/path-key.ts
+
+// ../../node_modules/.pnpm/@kevisual+load@0.0.6/node_modules/@kevisual/load/dist/load.js
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+var eventemitter3 = { exports: {} };
+var hasRequiredEventemitter3;
+function requireEventemitter3() {
+  if (hasRequiredEventemitter3)
+    return eventemitter3.exports;
+  hasRequiredEventemitter3 = 1;
+  (function(module) {
+    var has = Object.prototype.hasOwnProperty, prefix = "~";
+    function Events() {}
+    if (Object.create) {
+      Events.prototype = Object.create(null);
+      if (!new Events().__proto__)
+        prefix = false;
+    }
+    function EE(fn, context, once) {
+      this.fn = fn;
+      this.context = context;
+      this.once = once || false;
+    }
+    function addListener(emitter, event, fn, context, once) {
+      if (typeof fn !== "function") {
+        throw new TypeError("The listener must be a function");
+      }
+      var listener = new EE(fn, context || emitter, once), evt = prefix ? prefix + event : event;
+      if (!emitter._events[evt])
+        emitter._events[evt] = listener, emitter._eventsCount++;
+      else if (!emitter._events[evt].fn)
+        emitter._events[evt].push(listener);
+      else
+        emitter._events[evt] = [emitter._events[evt], listener];
+      return emitter;
+    }
+    function clearEvent(emitter, evt) {
+      if (--emitter._eventsCount === 0)
+        emitter._events = new Events;
+      else
+        delete emitter._events[evt];
+    }
+    function EventEmitter() {
+      this._events = new Events;
+      this._eventsCount = 0;
+    }
+    EventEmitter.prototype.eventNames = function eventNames() {
+      var names = [], events, name;
+      if (this._eventsCount === 0)
+        return names;
+      for (name in events = this._events) {
+        if (has.call(events, name))
+          names.push(prefix ? name.slice(1) : name);
+      }
+      if (Object.getOwnPropertySymbols) {
+        return names.concat(Object.getOwnPropertySymbols(events));
+      }
+      return names;
+    };
+    EventEmitter.prototype.listeners = function listeners(event) {
+      var evt = prefix ? prefix + event : event, handlers = this._events[evt];
+      if (!handlers)
+        return [];
+      if (handlers.fn)
+        return [handlers.fn];
+      for (var i = 0, l = handlers.length, ee = new Array(l);i < l; i++) {
+        ee[i] = handlers[i].fn;
+      }
+      return ee;
+    };
+    EventEmitter.prototype.listenerCount = function listenerCount(event) {
+      var evt = prefix ? prefix + event : event, listeners = this._events[evt];
+      if (!listeners)
+        return 0;
+      if (listeners.fn)
+        return 1;
+      return listeners.length;
+    };
+    EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
+      var evt = prefix ? prefix + event : event;
+      if (!this._events[evt])
+        return false;
+      var listeners = this._events[evt], len = arguments.length, args, i;
+      if (listeners.fn) {
+        if (listeners.once)
+          this.removeListener(event, listeners.fn, undefined, true);
+        switch (len) {
+          case 1:
+            return listeners.fn.call(listeners.context), true;
+          case 2:
+            return listeners.fn.call(listeners.context, a1), true;
+          case 3:
+            return listeners.fn.call(listeners.context, a1, a2), true;
+          case 4:
+            return listeners.fn.call(listeners.context, a1, a2, a3), true;
+          case 5:
+            return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
+          case 6:
+            return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
+        }
+        for (i = 1, args = new Array(len - 1);i < len; i++) {
+          args[i - 1] = arguments[i];
+        }
+        listeners.fn.apply(listeners.context, args);
+      } else {
+        var length = listeners.length, j;
+        for (i = 0;i < length; i++) {
+          if (listeners[i].once)
+            this.removeListener(event, listeners[i].fn, undefined, true);
+          switch (len) {
+            case 1:
+              listeners[i].fn.call(listeners[i].context);
+              break;
+            case 2:
+              listeners[i].fn.call(listeners[i].context, a1);
+              break;
+            case 3:
+              listeners[i].fn.call(listeners[i].context, a1, a2);
+              break;
+            case 4:
+              listeners[i].fn.call(listeners[i].context, a1, a2, a3);
+              break;
+            default:
+              if (!args)
+                for (j = 1, args = new Array(len - 1);j < len; j++) {
+                  args[j - 1] = arguments[j];
+                }
+              listeners[i].fn.apply(listeners[i].context, args);
+          }
+        }
+      }
+      return true;
+    };
+    EventEmitter.prototype.on = function on(event, fn, context) {
+      return addListener(this, event, fn, context, false);
+    };
+    EventEmitter.prototype.once = function once(event, fn, context) {
+      return addListener(this, event, fn, context, true);
+    };
+    EventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {
+      var evt = prefix ? prefix + event : event;
+      if (!this._events[evt])
+        return this;
+      if (!fn) {
+        clearEvent(this, evt);
+        return this;
+      }
+      var listeners = this._events[evt];
+      if (listeners.fn) {
+        if (listeners.fn === fn && (!once || listeners.once) && (!context || listeners.context === context)) {
+          clearEvent(this, evt);
+        }
+      } else {
+        for (var i = 0, events = [], length = listeners.length;i < length; i++) {
+          if (listeners[i].fn !== fn || once && !listeners[i].once || context && listeners[i].context !== context) {
+            events.push(listeners[i]);
+          }
+        }
+        if (events.length)
+          this._events[evt] = events.length === 1 ? events[0] : events;
+        else
+          clearEvent(this, evt);
+      }
+      return this;
+    };
+    EventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {
+      var evt;
+      if (event) {
+        evt = prefix ? prefix + event : event;
+        if (this._events[evt])
+          clearEvent(this, evt);
+      } else {
+        this._events = new Events;
+        this._eventsCount = 0;
+      }
+      return this;
+    };
+    EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+    EventEmitter.prototype.addListener = EventEmitter.prototype.on;
+    EventEmitter.prefixed = prefix;
+    EventEmitter.EventEmitter = EventEmitter;
+    {
+      module.exports = EventEmitter;
+    }
+  })(eventemitter3);
+  return eventemitter3.exports;
+}
+var eventemitter3Exports = requireEventemitter3();
+var EventEmitter = /* @__PURE__ */ getDefaultExportFromCjs(eventemitter3Exports);
+var reRunFn = (promiseOpts) => {
+  const timeout = promiseOpts.timeout || 5 * 60 * 1000;
+  const interval = promiseOpts.interval || 1000;
+  const checkSuccess = promiseOpts?.checkSuccess || (() => true);
+  const signal = promiseOpts.signal;
+  return new Promise(async (resolve, reject) => {
+    let intervalId;
+    let timeoutId = setTimeout(() => {
+      clearTimeout(intervalId);
+      resolve({
+        code: 500,
+        message: "timeout"
+      });
+    }, timeout);
+    const fn = promiseOpts.fn || (() => true);
+    const runFn = async () => {
+      if (signal?.aborted) {
+        clearInterval(intervalId);
+        clearTimeout(timeoutId);
+        return resolve({
+          code: 499,
+          message: "operation cancelled"
+        });
+      }
+      const res = await fn();
+      if (!!checkSuccess(res)) {
+        clearInterval(intervalId);
+        clearTimeout(timeoutId);
+        resolve({
+          code: 200,
+          data: res
+        });
+      } else {
+        setTimeout(() => {
+          runFn();
+        }, interval);
+      }
+    };
+    if (signal) {
+      signal.addEventListener("abort", () => {
+        clearInterval(intervalId);
+        clearTimeout(timeoutId);
+        resolve({
+          code: 499,
+          message: "operation cancelled"
+        });
+      });
+    }
+    runFn();
+  });
+};
+
+class BaseLoad {
+  modules = new Map;
+  event;
+  loading;
+  static reRunFn = reRunFn;
+  timeout = 5 * 60 * 1000;
+  constructor() {
+    this.event = new EventEmitter;
+    this.loading = false;
+  }
+  listenKey(key, listenOpts) {
+    const timeout = listenOpts?.timeout ?? this.timeout;
+    return new Promise((resolve) => {
+      const timeoutId = setTimeout(() => {
+        this.event.removeListener(key, onEvent);
+        resolve({
+          code: 500,
+          message: "timeout"
+        });
+      }, timeout);
+      const onEvent = (error) => {
+        clearTimeout(timeoutId);
+        if (error) {
+          return resolve({
+            code: 500,
+            message: error
+          });
+        }
+        const data = this.modules.get(key);
+        if (data?.loadSuccessClear) {
+          this.remove(key);
+        }
+        resolve({
+          code: 200,
+          data: data?.modules
+        });
+      };
+      this.event.once(key, onEvent);
+    });
+  }
+  async hasLoaded(key, hasLoadOpts) {
+    if (!key) {
+      return {
+        code: 404,
+        message: "key is required"
+      };
+    }
+    const has = this.modules.has(key);
+    if (!has) {
+      const isExist = hasLoadOpts?.isExist ?? true;
+      const timeout = hasLoadOpts?.timeout ?? this.timeout;
+      if (isExist) {
+        return await this.listenKey(key, { timeout });
+      }
+      return {
+        code: 404
+      };
+    }
+    const data = this.modules.get(key);
+    if (data?.status === "loaded") {
+      return {
+        code: 200,
+        data: data.modules
+      };
+    }
+    if (data?.status === "loading") {
+      return await this.listenKey(key, { timeout: hasLoadOpts?.timeout ?? this.timeout });
+    }
+    if (data?.status === "error") {
+      return {
+        code: 500,
+        message: "load error"
+      };
+    }
+    if (data?.status === "cancel") {
+      return {
+        code: 499,
+        message: "operation cancelled"
+      };
+    }
+    return {
+      code: 404
+    };
+  }
+  async loadFn(loadContent, opts) {
+    const key = opts.key;
+    if (!key) {
+      return {
+        code: 404,
+        message: "key is required"
+      };
+    }
+    const newModule = {
+      key: opts.key,
+      status: "loading",
+      loading: true,
+      loadSuccessClear: opts.loadSuccessClear ?? true
+    };
+    let errorMessage = "";
+    try {
+      const isReRun = opts.isReRun ?? false;
+      let res;
+      if (!isReRun) {
+        this.modules.set(key, newModule);
+        res = await loadContent();
+      } else {
+        newModule.controller = new AbortController;
+        const signal = newModule.controller.signal;
+        this.modules.set(key, newModule);
+        const data = await reRunFn({
+          timeout: opts.timeout,
+          interval: opts.interval,
+          checkSuccess: opts.checkSuccess,
+          fn: loadContent,
+          signal
+        });
+        newModule.controller = null;
+        if (data.code === 499) {
+          newModule.status = "cancel";
+          return {
+            code: 499,
+            message: "operation cancelled"
+          };
+        }
+        if (data.code !== 200) {
+          throw new Error(data.message);
+        }
+        res = data.data;
+      }
+      newModule.modules = res;
+      newModule.status = "loaded";
+      return {
+        code: 200,
+        data: res
+      };
+    } catch (error) {
+      errorMessage = error.message;
+      newModule.status = "error";
+      return {
+        code: 500,
+        message: error
+      };
+    } finally {
+      newModule.loading = false;
+      this.modules.set(opts.key, newModule);
+      if (!errorMessage) {
+        this.event.emit(opts.key);
+      } else {
+        this.event.emit(opts.key, errorMessage);
+      }
+    }
+  }
+  async load(loadContent, opts) {
+    this.loading = true;
+    const key = opts.key;
+    if (!key) {
+      return {
+        code: 404,
+        message: "key is required"
+      };
+    }
+    if (opts?.force) {
+      this.remove(key);
+    }
+    const has = this.modules.has(key);
+    if (has) {
+      return await this.hasLoaded(key);
+    }
+    if (typeof loadContent === "function") {
+      return this.loadFn(loadContent, opts);
+    }
+    console.error("loadContent is not a function and not has loaded");
+  }
+  remove(key) {
+    const has = this.modules.has(key);
+    if (has) {
+      this.checkRemoveController(key);
+      this.modules.delete(key);
+    }
+  }
+  emitLoaded(key) {
+    this.checkRemoveController(key);
+    this.event.emit(key);
+  }
+  setModule(key, data, loadData) {
+    const newModule = {
+      key,
+      status: "loaded",
+      loading: false,
+      modules: data || {},
+      ...loadData
+    };
+    this.modules.set(key, newModule);
+    this.emitLoaded(key);
+    return newModule;
+  }
+  cancel(key) {
+    this.checkRemoveController(key);
+  }
+  checkRemoveController(key) {
+    const data = this.modules.get(key);
+    if (data?.controller) {
+      data.controller?.abort?.();
+      delete data.controller;
+      this.modules.set(key, data);
+    }
+  }
+}
+
+// src/index.ts
+var gt = globalThis || window || self;
+var useEnv = (initEnv, initKey = "config", isOverwrite) => {
+  const env = gt[initKey];
+  const _env = env || initEnv;
+  if (!env) {
+    if (_env) {
+      gt[initKey] = _env;
+    } else {
+      gt[initKey] = {};
+    }
+  }
+  return gt[initKey];
+};
+var useEnvKey = (key, init, initKey = "config") => {
+  const _env = useEnv({}, initKey);
+  if (key && typeof _env[key] !== "undefined") {
+    return _env[key];
+  }
+  if (key && init) {
+    if (typeof init !== "function") {
+      _env[key] = init;
+    }
+    if (typeof init === "function") {
+      const result = init();
+      if (result instanceof Promise) {
+        return result.then((res) => {
+          _env[key] = res;
+          return res;
+        });
+      }
+      _env[key] = result;
+    }
+    return _env[key];
+  }
+  if (key) {
+    const baseLoad = new BaseLoad;
+    const voidFn = async () => {
+      return _env[key];
+    };
+    const checkFn = async () => {
+      const loadRes = await baseLoad.load(voidFn, {
+        key,
+        isReRun: true,
+        checkSuccess: () => _env[key],
+        timeout: 5 * 60 * 1000,
+        interval: 1000
+      });
+      if (loadRes.code !== 200) {
+        console.error("load key error");
+        return null;
+      }
+      return _env[key];
+    };
+    return checkFn();
+  }
+  console.error("key is empty ");
+  return null;
+};
+var useEnvKeyNew = (key, initKey = "config", opts) => {
+  const _env = useEnv({}, initKey);
+  if (key) {
+    delete _env[key];
+  }
+  if (opts?.getNew && opts.init) {
+    return useEnvKey(key, opts.init, initKey);
+  } else if (opts?.getNew) {
+    return useEnvKey(key, null, initKey);
+  }
+};
+var useContextKey = (key, init, isNew) => {
+  if (isNew) {
+    return useEnvKeyNew(key, "context", { getNew: true, init });
+  }
+  return useEnvKey(key, init, "context");
+};
+var use = useContextKey;
+var useConfigKey = (key, init, isNew) => {
+  if (isNew) {
+    return useEnvKeyNew(key, "config", { getNew: true, init });
+  }
+  return useEnvKey(key, init, "config");
+};
+
+class InitEnv {
+  static isInit = false;
+  static init(opts) {
+    if (InitEnv.isInit) {
+      return;
+    }
+    const { load = true, page = false } = opts || {};
+    InitEnv.isInit = true;
+    gt.useConfigKey = useConfigKey;
+    gt.useContextKey = useContextKey;
+    gt.use = use;
+    gt.webEnv = { useConfigKey, useContextKey, use };
+    load && (gt.Load = BaseLoad);
+  }
+}
+InitEnv.init();
+
+class Lexer {
+    constructor(input) {
+        this.pos = 0;
+        this.input = input.trim();
+    }
+    skipWhitespace() {
+        while (this.pos < this.input.length && /\s/.test(this.input[this.pos])) {
+            this.pos++;
+        }
+    }
+    readString(quote) {
+        this.pos++;
+        let result = '';
+        while (this.pos < this.input.length && this.input[this.pos] !== quote) {
+            result += this.input[this.pos];
+            this.pos++;
+        }
+        this.pos++;
+        return result;
+    }
+    readNumber() {
+        let result = '';
+        while (this.pos < this.input.length && /[\d.]/.test(this.input[this.pos])) {
+            result += this.input[this.pos];
+            this.pos++;
+        }
+        return result;
+    }
+    readIdentifier() {
+        let result = '';
+        while (this.pos < this.input.length && /[\w.]/.test(this.input[this.pos])) {
+            result += this.input[this.pos];
+            this.pos++;
+        }
+        return result;
+    }
+    isKeyword(value) {
+        const keywords = ['WHERE', 'AND', 'OR', 'ORDER', 'BY', 'ASC', 'DESC', 'LIMIT', 'IN', 'CONTAINS', 'LIKE', 'NOT', 'IS', 'NULL'];
+        return keywords.includes(value.toUpperCase());
+    }
+    nextToken() {
+        this.skipWhitespace();
+        if (this.pos >= this.input.length) {
+            return { type: 'EOF', value: '', pos: this.pos };
+        }
+        const char = this.input[this.pos];
+        if (char === "'" || char === '"') {
+            return { type: 'STRING', value: this.readString(char), pos: this.pos };
+        }
+        if (/\d/.test(char)) {
+            return { type: 'NUMBER', value: this.readNumber(), pos: this.pos };
+        }
+        if (char === ',') {
+            this.pos++;
+            return { type: 'COMMA', value: ',', pos: this.pos };
+        }
+        if (char === '[') {
+            this.pos++;
+            return { type: 'LBRACKET', value: '[', pos: this.pos };
+        }
+        if (char === ']') {
+            this.pos++;
+            return { type: 'RBRACKET', value: ']', pos: this.pos };
+        }
+        if (/[=<>!]/.test(char)) {
+            this.pos++;
+            if (char === '=' && this.pos < this.input.length && this.input[this.pos] === '=') {
+                this.pos++;
+                return { type: 'EQ', value: '==', pos: this.pos };
+            }
+            if (char === '!' && this.pos < this.input.length && this.input[this.pos] === '=') {
+                this.pos++;
+                return { type: 'NEQ', value: '!=', pos: this.pos };
+            }
+            if (char === '>') {
+                if (this.pos < this.input.length && this.input[this.pos] === '=') {
+                    this.pos++;
+                    return { type: 'GTE', value: '>=', pos: this.pos };
+                }
+                return { type: 'GT', value: '>', pos: this.pos };
+            }
+            if (char === '<') {
+                if (this.pos < this.input.length && this.input[this.pos] === '=') {
+                    this.pos++;
+                    return { type: 'LTE', value: '<=', pos: this.pos };
+                }
+                return { type: 'LT', value: '<', pos: this.pos };
+            }
+            return { type: 'EQ', value: char, pos: this.pos };
+        }
+        const identifier = this.readIdentifier();
+        const upperIdentifier = identifier.toUpperCase();
+        const keywords = {
+            'WHERE': 'WHERE',
+            'AND': 'AND',
+            'OR': 'OR',
+            'ORDER': 'ORDER',
+            'BY': 'BY',
+            'ASC': 'ASC',
+            'DESC': 'DESC',
+            'LIMIT': 'LIMIT',
+            'IN': 'IN',
+            'CONTAINS': 'CONTAINS',
+            'LIKE': 'LIKE',
+            'NOT': 'NOT',
+            'IS': 'IS',
+            'NULL': 'NULL'
+        };
+        if (keywords[upperIdentifier]) {
+            return { type: keywords[upperIdentifier], value: upperIdentifier, pos: this.pos };
+        }
+        return { type: 'IDENTIFIER', value: identifier, pos: this.pos };
+    }
+}
+class Parser {
+    constructor(lexer) {
+        this.lexer = lexer;
+        this.currentToken = this.lexer.nextToken();
+    }
+    eat(type) {
+        if (this.currentToken.type === type) {
+            this.currentToken = this.lexer.nextToken();
+        }
+        else {
+            throw new Error(`Expected ${type}, got ${this.currentToken.type}`);
+        }
+    }
+    parse() {
+        const statements = [];
+        if (this.currentToken.type === 'WHERE') {
+            statements.push(this.parseWhere());
+        }
+        if (this.currentToken.type === 'ORDER') {
+            statements.push(this.parseOrder());
+        }
+        if (this.currentToken.type === 'LIMIT') {
+            statements.push(this.parseLimit());
+        }
+        return statements;
+    }
+    parseWhere() {
+        this.eat('WHERE');
+        return { type: 'WhereClause', left: this.parseCondition() };
+    }
+    parseCondition() {
+        let left = this.parseExpression();
+        while (this.currentToken.type === 'AND' || this.currentToken.type === 'OR') {
+            const op = this.currentToken.type;
+            this.eat(op);
+            const right = this.parseExpression();
+            left = { type: 'LogicalOp', left, right, operator: op };
+        }
+        return left;
+    }
+    parseExpression() {
+        const field = this.currentToken.value;
+        this.eat('IDENTIFIER');
+        let operator;
+        let value;
+        if (this.currentToken.type === 'NOT') {
+            this.eat('NOT');
+            operator = 'NOT LIKE';
+            this.eat('LIKE');
+            value = this.parseValue();
+        }
+        else if (this.currentToken.type === 'LIKE') {
+            operator = 'LIKE';
+            this.eat('LIKE');
+            value = this.parseValue();
+        }
+        else if (this.currentToken.type === 'IS') {
+            this.eat('IS');
+            if (this.currentToken.type === 'NOT') {
+                operator = 'IS NOT NULL';
+                this.eat('NOT');
+                this.eat('NULL');
+            }
+            else {
+                operator = 'IS NULL';
+                this.eat('NULL');
+            }
+            value = null;
+        }
+        else if (this.currentToken.type === 'CONTAINS') {
+            operator = 'CONTAINS';
+            this.eat('CONTAINS');
+            value = this.parseValue();
+        }
+        else if (this.currentToken.type === 'IN') {
+            operator = 'IN';
+            this.eat('IN');
+            value = this.parseInList();
+        }
+        else {
+            const opType = this.currentToken.type;
+            this.eat(opType);
+            operator = opType;
+            value = this.parseValue();
+        }
+        return { type: 'Condition', field, operator, value };
+    }
+    parseInList() {
+        this.eat('LBRACKET');
+        const values = [];
+        while (this.currentToken.type !== 'RBRACKET') {
+            const node = this.parseValue();
+            values.push(node.value);
+            if (this.currentToken.type === 'COMMA') {
+                this.eat('COMMA');
+            }
+        }
+        this.eat('RBRACKET');
+        return values;
+    }
+    parseValue() {
+        if (this.currentToken.type === 'STRING') {
+            const value = this.currentToken.value;
+            this.eat('STRING');
+            return { type: 'Value', value };
+        }
+        if (this.currentToken.type === 'NUMBER') {
+            const value = parseFloat(this.currentToken.value);
+            this.eat('NUMBER');
+            return { type: 'Value', value };
+        }
+        throw new Error(`Expected value, got ${this.currentToken.type}`);
+    }
+    parseOrder() {
+        this.eat('ORDER');
+        this.eat('BY');
+        const field = this.currentToken.value;
+        this.eat('IDENTIFIER');
+        let direction = 'ASC';
+        if (this.currentToken.type === 'ASC' || this.currentToken.type === 'DESC') {
+            direction = this.currentToken.value;
+            this.eat(this.currentToken.type);
+        }
+        return { type: 'OrderClause', field, value: direction };
+    }
+    parseLimit() {
+        this.eat('LIMIT');
+        const value = parseFloat(this.currentToken.value);
+        this.eat('NUMBER');
+        return { type: 'LimitClause', value };
+    }
+}
+class Executor {
+    getValueByPath(obj, path) {
+        return path.split('.').reduce((acc, part) => acc?.[part], obj);
+    }
+    likeToRegex(pattern) {
+        let regex = '';
+        for (let i = 0; i < pattern.length; i++) {
+            const char = pattern[i];
+            if (char === '%') {
+                regex += '.*';
+            }
+            else if (char === '_') {
+                regex += '.';
+            }
+            else if (/[.*+?^${}()|[\]\\]/.test(char)) {
+                regex += '\\' + char;
+            }
+            else {
+                regex += char;
+            }
+        }
+        return new RegExp(`^${regex}$`, 'i');
+    }
+    evaluateCondition(node, item) {
+        if (node.type === 'Condition') {
+            const fieldValue = this.getValueByPath(item, node.field);
+            const { operator, value } = node;
+            const actualValue = value?.type === 'Value' ? value.value : value;
+            switch (operator) {
+                case 'EQ':
+                    return fieldValue === actualValue;
+                case 'NEQ':
+                    return fieldValue !== actualValue;
+                case 'GT':
+                    return fieldValue > actualValue;
+                case 'LT':
+                    return fieldValue < actualValue;
+                case 'GTE':
+                    return fieldValue >= actualValue;
+                case 'LTE':
+                    return fieldValue <= actualValue;
+                case 'IN':
+                    return Array.isArray(actualValue) && actualValue.includes(fieldValue);
+                case 'CONTAINS':
+                    return Array.isArray(fieldValue) && fieldValue.includes(actualValue);
+                case 'LIKE':
+                    if (typeof fieldValue !== 'string' || typeof actualValue !== 'string') {
+                        return false;
+                    }
+                    return this.likeToRegex(actualValue).test(fieldValue);
+                case 'NOT LIKE':
+                    if (typeof fieldValue !== 'string' || typeof actualValue !== 'string') {
+                        return true;
+                    }
+                    return !this.likeToRegex(actualValue).test(fieldValue);
+                case 'IS NULL':
+                    return fieldValue === null || fieldValue === undefined;
+                case 'IS NOT NULL':
+                    return fieldValue !== null && fieldValue !== undefined;
+                default:
+                    return false;
+            }
+        }
+        if (node.type === 'LogicalOp') {
+            const leftResult = this.evaluateCondition(node.left, item);
+            const rightResult = this.evaluateCondition(node.right, item);
+            return node.operator === 'AND'
+                ? leftResult && rightResult
+                : leftResult || rightResult;
+        }
+        return true;
+    }
+    execute(statements, data) {
+        let result = [...data];
+        for (const stmt of statements) {
+            if (stmt.type === 'WhereClause') {
+                result = result.filter(item => this.evaluateCondition(stmt.left, item));
+            }
+            else if (stmt.type === 'OrderClause') {
+                const field = stmt.field;
+                const direction = stmt.value;
+                result.sort((a, b) => {
+                    const aVal = this.getValueByPath(a, field);
+                    const bVal = this.getValueByPath(b, field);
+                    if (aVal === bVal)
+                        return 0;
+                    const cmp = aVal > bVal ? 1 : -1;
+                    return direction === 'ASC' ? cmp : -cmp;
+                });
+            }
+            else if (stmt.type === 'LimitClause') {
+                result = result.slice(0, stmt.value);
+            }
+        }
+        return result;
+    }
+}
+function filter(data, query) {
+    if (!query || query.trim() === '') {
+        return data;
+    }
+    const lexer = new Lexer(query);
+    const parser = new Parser(lexer);
+    const ast = parser.parse();
+    const executor = new Executor();
+    return executor.execute(ast, data);
+}
+
+const createRouterAgentPluginFn = (opts) => {
+    let router = opts?.router;
+    if (!router) {
+        const app = useContextKey('app');
+        router = app.router;
+    }
+    if (!router) {
+        throw new Error('Router 参数缺失');
+    }
+    const _routes = filter(router.routes, opts?.query || '');
+    const routes = _routes.filter(r => {
+        const metadata = r.metadata;
+        if (metadata && metadata.tags && metadata.tags.includes('opencode')) {
+            return !!metadata.skill;
+        }
+        return false;
+    });
+    // opencode run "查看系统信息"
+    const AgentPlugin = async ({ project, client, $, directory, worktree }) => {
+        return {
+            'tool': {
+                ...routes.reduce((acc, route) => {
+                    const metadata = route.metadata;
+                    acc[metadata.skill] = {
+                        name: metadata.title || metadata.skill,
+                        description: metadata.summary || '',
+                        args: metadata.args || {},
+                        async execute(args) {
+                            const res = await router.run({
+                                path: route.path,
+                                key: route.key,
+                                payload: args
+                            }, { appId: router.appId });
+                            if (res.code === 200) {
+                                if (res.data?.content) {
+                                    return res.data.content;
+                                }
+                                if (res.data?.final) {
+                                    return '调用程序成功';
+                                }
+                                const str = JSON.stringify(res.data || res, null, 2);
+                                if (str.length > 10000) {
+                                    return str.slice(0, 10000) + '... (truncated)';
+                                }
+                                return str;
+                            }
+                            return `Error: ${res?.message || '无法获取结果'}`;
+                        }
+                    };
+                    return acc;
+                }, {})
+            },
+            'tool.execute.before': async (opts) => {
+                // console.log('CnbPlugin: tool.execute.before', opts.tool);
+                // delete toolSkills['cnb-login-verify']
+            }
+        };
+    };
+    return AgentPlugin;
+};
+
+export { createRouterAgentPluginFn };