@ai-setting/roy-agent-core 1.4.12 → 1.4.14

package/dist/shared/@ai-setting/roy-agent-core-0hdry23r.js

@@ -0,0 +1,419 @@
+import {
+  init_decorator
+} from "./roy-agent-core-04qgbjbe.js";
+import {
+  envKeyToConfigKey
+} from "./roy-agent-core-jv3b7v9w.js";
+import {
+  BaseComponent
+} from "./roy-agent-core-m2x48hw6.js";
+import {
+  createLogger,
+  init_logger,
+  setConfigComponent,
+  setQuietMode
+} from "./roy-agent-core-yn761yve.js";
+import {
+  getTracerProvider,
+  init_propagation,
+  init_tracer_provider,
+  init_types,
+  propagation
+} from "./roy-agent-core-1k28kg7h.js";
+import {
+  SQLiteSpanStorage,
+  init_span_storage
+} from "./roy-agent-core-j8zx62zr.js";
+import {
+  __require
+} from "./roy-agent-core-fs0mn2jk.js";
+
+// packages/core/src/env/log-trace/index.ts
+init_types();
+init_span_storage();
+
+// packages/core/src/env/log-trace/log-trace-component.ts
+init_logger();
+init_tracer_provider();
+init_span_storage();
+import { z } from "zod";
+import { join } from "path";
+
+// packages/core/src/env/log-trace/trace-context.ts
+import { AsyncLocalStorage } from "async_hooks";
+var contextStore = new AsyncLocalStorage;
+function createLightweightContext() {
+  return new LightweightTraceContext;
+}
+
+class LightweightTraceContext {
+  getRequestId() {
+    return contextStore.getStore()?.requestId;
+  }
+  getSpanContext() {
+    return contextStore.getStore()?.spanContext;
+  }
+  setSpanContext(spanContext) {
+    const store = contextStore.getStore();
+    if (store) {
+      store.spanContext = spanContext;
+    }
+  }
+  runWithContext(fn) {
+    const store = contextStore.getStore();
+    if (store) {
+      return contextStore.run(store, fn);
+    }
+    return fn();
+  }
+  runWithNewContext(requestId, sessionId, fn) {
+    const context = {
+      requestId,
+      sessionId,
+      timestamp: Date.now(),
+      spanContext: {
+        traceId: requestId,
+        spanId: this.generateSpanId()
+      }
+    };
+    return contextStore.run(context, fn);
+  }
+  async runWithContextAsync(fn) {
+    const store = contextStore.getStore();
+    if (store) {
+      return contextStore.run(store, fn);
+    }
+    return fn();
+  }
+  async runWithNewContextAsync(requestId, sessionId, fn) {
+    const context = {
+      requestId,
+      sessionId,
+      timestamp: Date.now(),
+      spanContext: {
+        traceId: requestId,
+        spanId: this.generateSpanId()
+      }
+    };
+    return contextStore.run(context, fn);
+  }
+  generateRequestId() {
+    return `req_${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;
+  }
+  generateSpanId() {
+    return `span_${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;
+  }
+  initContext(requestId, sessionId) {
+    const context = {
+      requestId,
+      sessionId,
+      timestamp: Date.now(),
+      spanContext: {
+        traceId: requestId,
+        spanId: this.generateSpanId()
+      }
+    };
+    contextStore.enterWith(context);
+  }
+  startNewContext(requestId, sessionId) {
+    const context = {
+      requestId,
+      sessionId,
+      timestamp: Date.now(),
+      spanContext: {
+        traceId: requestId,
+        spanId: this.generateSpanId()
+      }
+    };
+    const previousStore = contextStore.getStore();
+    contextStore.enterWith(context);
+    return () => {
+      contextStore.enterWith(previousStore);
+    };
+  }
+}
+var traceContextImpl = null;
+function initTraceContext(options) {
+  traceContextImpl = createLightweightContext();
+  return traceContextImpl;
+}
+
+// packages/core/src/env/log-trace/log-trace-config-registration.ts
+var LOG_TRACE_DEFAULTS = {
+  "log-trace.logging.enabled": true,
+  "log-trace.logging.level": "info",
+  "log-trace.logging.quiet": false,
+  "log-trace.tracing.enabled": true
+};
+var LOG_TRACE_CONFIG_REGISTRATION = {
+  name: "log-trace",
+  sources: [
+    { type: "env", envPrefix: "LOG_TRACE", priority: 20, watch: false }
+  ],
+  keys: [
+    { key: "log-trace.logging.enabled", sources: ["env", "file"] },
+    { key: "log-trace.logging.level", sources: ["env", "file"] },
+    { key: "log-trace.logging.quiet", sources: ["env", "file"] },
+    { key: "log-trace.logging.dir", sources: ["env", "file"] },
+    { key: "log-trace.logging.file", sources: ["env", "file"] },
+    { key: "log-trace.logging.maxOutput", sources: ["env", "file"] },
+    { key: "log-trace.tracing.enabled", sources: ["env", "file"] },
+    { key: "log-trace.tracing.dbPath", sources: ["env", "file"] }
+  ]
+};
+
+// packages/core/src/env/log-trace/log-trace-component.ts
+function getDefaultDataDir() {
+  try {
+    const xdg = __require("xdg-basedir");
+    if (xdg.xdgData) {
+      return xdg.xdgData;
+    }
+  } catch {}
+  const home = process.env.HOME || process.env.USERPROFILE || "/tmp";
+  return join(home, ".local", "share");
+}
+function getDefaultLogDir() {
+  return join(getDefaultDataDir(), "roy-agent", "logs");
+}
+function getDefaultSpanDbPath() {
+  return join(getDefaultDataDir(), "roy-agent", "traces.db");
+}
+var LogTraceConfigSchema = z.object({
+  logging: z.object({
+    enabled: z.boolean().default(true),
+    level: z.enum(["debug", "info", "warn", "error"]).default("info"),
+    quiet: z.boolean().default(false),
+    file: z.string().default("app.log"),
+    dir: z.string().default(getDefaultLogDir()),
+    maxOutput: z.number().default(0)
+  }).default({}),
+  tracing: z.object({
+    enabled: z.boolean().default(true),
+    dbPath: z.string().optional()
+  }).default({}),
+  initContext: z.object({
+    requestId: z.string().optional(),
+    sessionId: z.string().optional()
+  }).optional()
+});
+
+class LogTraceComponent extends BaseComponent {
+  name = "log-trace";
+  version = "1.0.0";
+  config;
+  configComponent;
+  tracer;
+  traceContext;
+  configWatcher;
+  constructor() {
+    super();
+  }
+  async init(config) {
+    await super.init(config);
+    const options = config.options;
+    if (!options?.configComponent) {
+      throw new Error("ConfigComponent is required for LogTraceComponent initialization");
+    }
+    this.configComponent = options.configComponent;
+    await this.registerConfig(options);
+    this.traceContext = initTraceContext();
+    const provider = getTracerProvider();
+    const _unused = provider;
+    await provider.initialize();
+    this.tracer = provider.getTracer("roy-tracer");
+    this.configureLogging();
+    if (this.config?.initContext?.requestId) {
+      this.traceContext.initContext(this.config.initContext.requestId, this.config.initContext.sessionId);
+    }
+    this.setStatus("running");
+  }
+  async registerConfig(options) {
+    const configComponent = options.configComponent;
+    if (!configComponent)
+      return;
+    const { configPath, envPrefix, config } = options;
+    const prefix = envPrefix !== undefined ? envPrefix : "LOG_TRACE";
+    configComponent.registerComponent(LOG_TRACE_CONFIG_REGISTRATION);
+    if (configPath) {
+      configComponent.registerSource({
+        type: "file",
+        relativePath: configPath,
+        optional: true,
+        watch: false
+      });
+    }
+    configComponent.registerSource({
+      type: "env",
+      envPrefix: prefix,
+      priority: 20,
+      watch: false
+    });
+    await configComponent.load("log-trace");
+    for (const envKey of Object.keys(process.env)) {
+      const configKey = envKeyToConfigKey(envKey, prefix, "log-trace");
+      if (!configKey)
+        continue;
+      const value = process.env[envKey];
+      if (value !== undefined) {
+        await configComponent.set(configKey, value);
+      }
+    }
+    for (const [key, value] of Object.entries(LOG_TRACE_DEFAULTS)) {
+      if (configComponent.get(key) === undefined) {
+        await configComponent.set(key, value);
+      }
+    }
+    if (configComponent.get("log-trace.logging.dir") === undefined) {
+      await configComponent.set("log-trace.logging.dir", getDefaultLogDir());
+    }
+    if (configComponent.get("log-trace.logging.file") === undefined) {
+      await configComponent.set("log-trace.logging.file", "app.log");
+    }
+    if (configComponent.get("log-trace.logging.maxOutput") === undefined) {
+      await configComponent.set("log-trace.logging.maxOutput", 0);
+    }
+    if (configComponent.get("log-trace.tracing.dbPath") === undefined) {
+      await configComponent.set("log-trace.tracing.dbPath", getDefaultSpanDbPath());
+    }
+    if (config) {
+      const flatConfig = this.flattenConfig(config);
+      for (const [key, value] of Object.entries(flatConfig)) {
+        await configComponent.set(key, value);
+      }
+    }
+    this.registerConfigWatcher(configComponent);
+    setConfigComponent(configComponent);
+    const tracingDbPath = configComponent.get("log-trace.tracing.dbPath");
+    this.config = {
+      logging: {
+        enabled: configComponent.get("log-trace.logging.enabled") ?? true,
+        level: configComponent.get("log-trace.logging.level") ?? "info",
+        quiet: configComponent.get("log-trace.logging.quiet") ?? false,
+        file: configComponent.get("log-trace.logging.file") ?? "app.log",
+        dir: configComponent.get("log-trace.logging.dir") ?? getDefaultLogDir(),
+        maxOutput: configComponent.get("log-trace.logging.maxOutput") ?? 0
+      },
+      tracing: {
+        enabled: configComponent.get("log-trace.tracing.enabled") ?? true,
+        dbPath: tracingDbPath ?? getDefaultSpanDbPath()
+      }
+    };
+  }
+  flattenConfig(obj, prefix = "log-trace") {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      const fullKey = `${prefix}.${key}`;
+      if (value && typeof value === "object" && !Array.isArray(value)) {
+        Object.assign(result, this.flattenConfig(value, fullKey));
+      } else {
+        result[fullKey] = value;
+      }
+    }
+    return result;
+  }
+  registerConfigWatcher(configComponent) {
+    if (typeof configComponent.watch !== "function") {
+      return;
+    }
+    this.configWatcher = configComponent.watch("log-trace.*", (event) => {
+      this.onConfigChange(event);
+    });
+  }
+  onConfigChange(event) {
+    if (event.key === "log-trace.logging.quiet") {
+      setQuietMode(event.newValue);
+    }
+  }
+  createStorage() {
+    if (this.configComponent) {
+      const dbPath = this.configComponent.get("log-trace.tracing.dbPath");
+      if (dbPath) {
+        return new SQLiteSpanStorage(dbPath);
+      }
+    }
+    if (this.config?.tracing?.dbPath) {
+      return new SQLiteSpanStorage(this.config.tracing.dbPath);
+    }
+    return new SQLiteSpanStorage(getDefaultSpanDbPath());
+  }
+  configureLogging() {
+    if (!this.config?.logging)
+      return;
+    if (this.config.logging.quiet) {
+      setQuietMode(true);
+    }
+  }
+  initContext(requestId, sessionId) {
+    if (!this.traceContext) {
+      throw new Error("Component not initialized");
+    }
+    this.traceContext.initContext(requestId, sessionId);
+  }
+  startContext(requestId, sessionId) {
+    if (!this.traceContext) {
+      throw new Error("Component not initialized");
+    }
+    return this.traceContext.startNewContext(requestId, sessionId);
+  }
+  getLogger(prefix) {
+    return createLogger(prefix || "app");
+  }
+  getTracer() {
+    if (!this.tracer) {
+      throw new Error("Component not initialized");
+    }
+    return this.tracer;
+  }
+  getTraceContext() {
+    return this.traceContext;
+  }
+  getRequestId() {
+    return this.traceContext?.getRequestId();
+  }
+  async onStop() {
+    this.configWatcher?.();
+    this.configWatcher = undefined;
+    this.tracer = undefined;
+    this.setStatus("stopped");
+  }
+}
+
+// packages/core/src/env/log-trace/index.ts
+init_tracer_provider();
+init_propagation();
+
+// packages/core/src/env/log-trace/opentelemetry/propagation-env.ts
+init_propagation();
+init_tracer_provider();
+function injectToEnv(env = {}) {
+  const provider = getTracerProvider();
+  const tracer = provider.getTracer("roy-tracer");
+  tracer.injectToEnv(env);
+  return env;
+}
+function injectToEnvWithContext(env, context) {
+  propagation.inject(env, context);
+  return env;
+}
+function injectToEnvFromCarrier(target, source) {
+  const extracted = propagation.extract(source);
+  if (extracted) {
+    const context = {
+      traceId: extracted.traceId,
+      spanId: extracted.spanId,
+      parentSpanId: undefined
+    };
+    propagation.inject(target, context);
+  }
+  return target;
+}
+function getTraceparentHeader() {
+  return propagation.getTraceparentHeader();
+}
+
+// packages/core/src/env/log-trace/index.ts
+init_logger();
+init_decorator();
+
+export { getDefaultLogDir, getDefaultSpanDbPath, LogTraceConfigSchema, LogTraceComponent, injectToEnv, injectToEnvWithContext, injectToEnvFromCarrier, getTraceparentHeader };

package/dist/shared/@ai-setting/roy-agent-core-0sgn3de4.js

@@ -0,0 +1,102 @@
+import {
+  __esm,
+  __export
+} from "./roy-agent-core-fs0mn2jk.js";
+
+// packages/core/src/env/session/search-query-parser.ts
+var exports_search_query_parser = {};
+__export(exports_search_query_parser, {
+  parseSearchQuery: () => parseSearchQuery,
+  matchesQuery: () => matchesQuery
+});
+function parseSearchQuery(query) {
+  const result = {
+    required: [],
+    excluded: [],
+    phrases: []
+  };
+  if (!query || !query.trim()) {
+    return result;
+  }
+  const phraseRegex = /"([^"]+)"/g;
+  let match;
+  while ((match = phraseRegex.exec(query)) !== null) {
+    result.phrases.push(match[1].toLowerCase());
+  }
+  query = query.replace(phraseRegex, "");
+  query = query.replace(/\s+/g, " ").trim();
+  if (!query) {
+    return result;
+  }
+  const parts = [];
+  let remaining = query;
+  const singleOpRegex = /\s+(AND|OR|NOT)\s+/gi;
+  let opMatch;
+  while ((opMatch = singleOpRegex.exec(remaining)) !== null) {
+    const op = opMatch[1].toUpperCase();
+    const beforeText = remaining.slice(0, opMatch.index).trim();
+    if (beforeText) {
+      parts.push({ text: beforeText, operator: undefined });
+    }
+    parts.push({ text: op, operator: op });
+    remaining = remaining.slice(opMatch.index + opMatch[0].length);
+    singleOpRegex.lastIndex = 0;
+  }
+  if (remaining.trim()) {
+    parts.push({ text: remaining.trim(), operator: undefined });
+  }
+  let currentOperator = "AND";
+  for (const part of parts) {
+    if (part.operator) {
+      currentOperator = part.operator;
+    } else {
+      const wordRegex = /[\w\u4e00-\u9fff\u3040-\u309f\u30a0-\u30ff]+/gu;
+      const words = part.text.match(wordRegex) || [];
+      for (const word of words) {
+        const lowerWord = word.toLowerCase();
+        if (lowerWord === "and" || lowerWord === "or" || lowerWord === "not") {
+          currentOperator = lowerWord.toUpperCase();
+          continue;
+        }
+        if (currentOperator === "NOT") {
+          if (!result.excluded.includes(lowerWord)) {
+            result.excluded.push(lowerWord);
+          }
+        } else {
+          if (!result.required.includes(lowerWord)) {
+            result.required.push(lowerWord);
+          }
+        }
+        currentOperator = "AND";
+      }
+    }
+  }
+  return result;
+}
+function matchesQuery(content, query) {
+  if (!content) {
+    return query.required.length === 0 && query.phrases.length === 0;
+  }
+  const lowerContent = content.toLowerCase();
+  for (const term of query.excluded) {
+    if (lowerContent.includes(term.toLowerCase())) {
+      return false;
+    }
+  }
+  for (const phrase of query.phrases) {
+    if (!lowerContent.includes(phrase)) {
+      return false;
+    }
+  }
+  if (query.required.length > 0) {
+    for (const term of query.required) {
+      if (!lowerContent.includes(term)) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+var init_search_query_parser = () => {};
+
+export { parseSearchQuery, matchesQuery, exports_search_query_parser, init_search_query_parser };

package/dist/{env/task/tools/index.js → shared/@ai-setting/roy-agent-core-12x57kf1.js}

@@ -1,54 +1,3 @@
-// @bun
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-function __accessProp(key) {
-  return this[key];
-}
-var __toCommonJS = (from) => {
-  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
-  if (entry)
-    return entry;
-  entry = __defProp({}, "__esModule", { value: true });
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (var key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(entry, key))
-        __defProp(entry, key, {
-          get: __accessProp.bind(from, key),
-          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-        });
-  }
-  __moduleCache.set(from, entry);
-  return entry;
-};
-var __moduleCache;
-var __returnValue = (v) => v;
-function __exportSetter(name, newValue) {
-  this[name] = __returnValue.bind(null, newValue);
-}
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: __exportSetter.bind(all, name)
-    });
-};
-var __legacyDecorateClassTS = function(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
-    r = Reflect.decorate(decorators, target, key, desc);
-  else
-    for (var i = decorators.length - 1;i >= 0; i--)
-      if (d = decorators[i])
-        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-var __require = import.meta.require;
-
 // packages/core/src/env/task/tools/task-types.ts
 import { z } from "zod";
 var CreateTaskToolSchema = z.object({
@@ -334,11 +283,4 @@ function completeTaskTool(taskComponent) {
     }
   };
 }
-export {
-  updateTaskTool,
-  listTasksTool,
-  getTaskTool,
-  deleteTaskTool,
-  createTaskTool,
-  completeTaskTool
-};
+export { createTaskTool, getTaskTool, listTasksTool, updateTaskTool, deleteTaskTool, completeTaskTool };