@ai-setting/roy-agent-core 1.5.14-test → 1.5.15-test

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

@@ -1,419 +0,0 @@
-import {
-  envKeyToConfigKey
-} from "./roy-agent-core-qxhq8ven.js";
-import {
-  BaseComponent
-} from "./roy-agent-core-kkbwepqb.js";
-import {
-  init_decorator
-} from "./roy-agent-core-zgypchmt.js";
-import {
-  createLogger,
-  init_logger,
-  setConfigComponent,
-  setQuietMode
-} from "./roy-agent-core-44hnfb02.js";
-import {
-  getTracerProvider,
-  init_propagation,
-  init_tracer_provider,
-  init_types,
-  propagation
-} from "./roy-agent-core-xs5rsgat.js";
-import {
-  SQLiteSpanStorage,
-  init_span_storage
-} from "./roy-agent-core-psv4v63c.js";
-import {
-  __require
-} from "./roy-agent-core-fs0mn2jk.js";
-
-// src/env/log-trace/index.ts
-init_types();
-init_span_storage();
-
-// src/env/log-trace/log-trace-component.ts
-init_logger();
-init_tracer_provider();
-init_span_storage();
-import { z } from "zod";
-import { join } from "path";
-
-// 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;
-}
-
-// 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"] }
-  ]
-};
-
-// 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");
-  }
-}
-
-// src/env/log-trace/index.ts
-init_tracer_provider();
-init_propagation();
-
-// 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();
-}
-
-// src/env/log-trace/index.ts
-init_logger();
-init_decorator();
-
-export { getDefaultLogDir, getDefaultSpanDbPath, LogTraceConfigSchema, LogTraceComponent, injectToEnv, injectToEnvWithContext, injectToEnvFromCarrier, getTraceparentHeader };